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

import { OnModuleInit, Inject } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { InputService } from '@victorradael/protospack';
import {
  objectCamelToSnake,
  objectSnakeToCamel,
} from 'src/utils/CaseConverter';
import {
  ICreateInputRequest,
  IIdRequest,
  ITestConnectionRequest,
  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: ICreateInputRequest) {
    console.log('InputClientService', 'Create');

    const createInputResponse = await new Promise((resolve, reject) => {
      this.inputService.Create(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: ITestConnectionRequest) {
    console.log('InputClientService', 'TestConnection');
    const testConnectionResponse = await new Promise((resolve, reject) => {
      this.inputService.TestConnection(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;
  }
}