maestro/src/clients/inputs/client.service.ts

import { OnModuleInit, Inject } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import {
  InputCreateS3Request,
  InputNewCreateRequest,
  InputService,
  TestConnectionGetColumnsRequest,
  TestConnectionRequest,
} from '@victorradael/protospack';
import {
  objectCamelToSnake,
  objectSnakeToCamel,
} from 'src/utils/CaseConverter';
import { IIdRequest, UpdateInputRequest } from './interfaces';

export class InputsClientService implements OnModuleInit {
  private inputService: InputService;
  constructor(
    @Inject('INPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
  ) {}

  onModuleInit() {
    this.inputService =
      this.grpcClient.getService<InputService>('InputService');
  }

  async create(createInputDto: InputNewCreateRequest) {
    console.log('InputClientService', 'Create');

    const createInputResponse = await new Promise((resolve, reject) => {
      this.inputService
        .NewCreate(objectSnakeToCamel(createInputDto))
        .subscribe({
          next(x) {
            resolve(objectCamelToSnake(x));
          },
          error(err) {
            console.log('Observable Error');
            reject(err);
          },
          complete() {
            console.log('done');
          },
        });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return createInputResponse;
  }

  async createS3Inputs(createInputDto: InputCreateS3Request) {
    console.log('InputClientService', 'Create');

    const createInputResponse = await new Promise((resolve, reject) => {
      this.inputService.CreateS3(objectSnakeToCamel(createInputDto)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return createInputResponse;
  }

  async findOne(data: IIdRequest) {
    console.log('InputClientService', 'FindOne');

    const findOneInputResponse = await new Promise((resolve, reject) => {
      this.inputService.FindOne(objectSnakeToCamel(data)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return findOneInputResponse;
  }

  async findAll(data) {
    console.log('InputClientService', 'FindAll');

    const findAllInputResponse = await new Promise((resolve, reject) => {
      this.inputService.FindAll(objectSnakeToCamel(data)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return findAllInputResponse;
  }

  async update(updateInputDTO: UpdateInputRequest) {
    console.log('InputClientService', 'Update');
    const updateInputResponse = await new Promise((resolve, reject) => {
      this.inputService.Update(objectSnakeToCamel(updateInputDTO)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return updateInputResponse;
  }

  async remove(idRequest: IIdRequest) {
    console.log('InputClientService', 'Remove');

    const removeInputResponse = await new Promise((resolve, reject) => {
      this.inputService.Remove(objectSnakeToCamel(idRequest)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return removeInputResponse;
  }

  async testConnection(data: TestConnectionRequest) {
    console.log('InputClientService', 'TestConnection');
    const testConnectionResponse = await new Promise((resolve, reject) => {
      this.inputService.NewTestConnection(objectSnakeToCamel(data)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return testConnectionResponse;
  }

  async getColumns(data: TestConnectionGetColumnsRequest) {
    console.log('InputClientService', 'TestConnection/Get-Columns');
    const getColumnsResponse = await new Promise((resolve, reject) => {
      this.inputService.GetColumns(objectSnakeToCamel(data)).subscribe({
        next(x) {
          resolve(objectCamelToSnake(x));
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return getColumnsResponse;
  }
}