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 } from 'src/utils/CaseConverter';
import { ICreateTransformationsRequest, IdRequest } 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(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() {
    console.log('TransformationClientService', 'FindAll');

    const findAllTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService.findAll({}).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({ id }: IdRequest) {
    console.log('TransformationClientService', 'FindOne');

    const findOneTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService.findOne({ id }).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(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({ id }: IdRequest) {
    console.log('TransformationClientService', 'Remove');

    const removeTransformationResponse = await new Promise(
      (resolve, reject) => {
        this.transformationService.remove({ id }).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);
  }
}