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

import { Controller, Inject, OnModuleInit, Post } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { TransformationsServiceInterface } from '@victorradael/protospack';
import {
  objectCamelToSnake,
  objectSnakeToCamel,
} from 'src/utils/CaseConverter';
import { ICreateTransformationsRequest, IIdRequest } from './interfaces';

@Controller('transformation')
export class TransformationsClientService implements OnModuleInit {
  private transformationService: TransformationsServiceInterface;
  constructor(
    @Inject('TRANSFORMATIONS_PACKAGE') private readonly grpcClient: ClientGrpc,
  ) {}

  onModuleInit() {
    this.transformationService =
      this.grpcClient.getService<TransformationsServiceInterface>(
        'TransformationService',
      );
  }

  @Post()
  async create(createTransformationsDto: ICreateTransformationsRequest) {
    console.log('TransformationClientService', 'Create');

    const createTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService
          .Create(objectSnakeToCamel(createTransformationsDto))
          .subscribe({
            next(x) {
              resolve(x);
            },
            error(err) {
              console.log('Observable Error');
              reject(err);
            },
            complete() {
              console.log('done');
            },
          });
      },
    )
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    const convertedTransforms = createTransformationResponse[
      'transformations'
    ].map((tr) => {
      return objectCamelToSnake(tr);
    });

    return { transformations: convertedTransforms };
  }

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

    const findAllTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService.FindAll(objectSnakeToCamel(data)).subscribe({
          next(x) {
            resolve(x);
          },
          error(err) {
            console.log('Observable Error');
            reject(err);
          },
          complete() {
            console.log('done');
          },
        });
      },
    )
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });
    const convertedTransforms = findAllTransformationResponse[
      'transformations'
    ].map((tr) => {
      return objectCamelToSnake(tr);
    });
    return { transformations: convertedTransforms };
  }

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

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

    return objectCamelToSnake(findOneTransformationResponse);
  }

  async update(updateTransformationDTO) {
    console.log('TransformationClientService', 'Update');

    const updateTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService
          .Update(objectSnakeToCamel(updateTransformationDTO))
          .subscribe({
            next(x) {
              resolve(x);
            },
            error(err) {
              console.log('Observable Error');
              reject(err);
            },
            complete() {
              console.log('done');
            },
          });
      },
    )
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return objectCamelToSnake(updateTransformationResponse);
  }

  async remove(data: IIdRequest) {
    console.log('TransformationClientService', 'Remove');

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

    return objectCamelToSnake(removeTransformationResponse);
  }
}