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

import {
  OnModuleInit,
  Inject,
  HttpException,
  HttpStatus,
} from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import {
  DecodeGrpcStruct,
  EncodeJsonToGrpcStruct,
  InputCreateS3Request,
  InputNewCreateRequest,
  InputService,
  TestConnectionGetColumnsRequest,
  TestConnectionRequest,
} from '@victorradael/protospack';
import axios from 'axios';
import { lastValueFrom } from 'rxjs';
import { InputModel } from 'src/modules/inputs/dtos/input.model';
import {
  objectCamelToSnake,
  objectSnakeToCamel,
} from 'src/utils/CaseConverter';
import { mustache } from 'src/utils/mustache';
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 newCreate(createInputDto: InputNewCreateRequest) {
    console.log('InputClientService', 'Create');

    const input = await lastValueFrom(
      this.inputService.NewCreate(objectSnakeToCamel(createInputDto)),
    );
    objectCamelToSnake(input);
    return input;
  }

  async createGeneric(createInputGeneric) {
    console.log('InputClientService', 'Create');
    const { info, ...data } = createInputGeneric;
    data.credentials = await this.getInputTokens(data);
    if (data.options) delete data.options;
    if (data.credentials.oauth_code) delete data.credentials.oauth_code;
    const grpcPayload = {
      input: EncodeJsonToGrpcStruct(data),
      info,
    };
    objectSnakeToCamel(grpcPayload);

    const structReturn = await lastValueFrom(
      this.inputService.Create(grpcPayload),
    );
    objectCamelToSnake(structReturn);
    const inputCreated = DecodeGrpcStruct(structReturn.input);
    return { input: inputCreated };
  }

  async createS3Inputs(createInputDto: InputCreateS3Request) {
    console.log('InputClientService', 'Create');
    objectSnakeToCamel(createInputDto);
    const createInputResponse = await lastValueFrom(
      this.inputService.CreateS3(createInputDto),
    ).catch((e) => {
      throw new HttpException(e.details, 500);
    });
    console.log('done');
    objectCamelToSnake(createInputResponse);
    return createInputResponse;
  }

  async findOne(data: IIdRequest) {
    console.log('InputClientService', 'FindOne');
    const findOneInputResponse = await lastValueFrom(
      this.inputService.FindOne(objectSnakeToCamel(data)),
    ).catch((e) => {
      throw new HttpException(e.details, HttpStatus.INTERNAL_SERVER_ERROR);
    });
    objectCamelToSnake(findOneInputResponse);
    return findOneInputResponse;
  }

  async findAll(data) {
    console.log('InputClientService', 'FindAll');
    const findAllInputResponse = await lastValueFrom(
      this.inputService.FindAll(objectSnakeToCamel(data)),
    ).catch((e) => {
      throw new HttpException(e.details, HttpStatus.INTERNAL_SERVER_ERROR);
    });
    findAllInputResponse.inputs.forEach((input) => objectCamelToSnake(input));

    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;
  }
  async getAuthSecrets(plugin) {
    switch (plugin) {
      case 'hubspot':
        return {
          client_id: process.env.HUBSPOT_CLIENT_ID || '',
          client_secret: process.env.HUBSPOT_CLIENT_SECRET || '',
        };
    }
    return {};
  }
  async getInputTokens(input: InputModel) {
    const { credentials, options } = input;
    const credentialsTokens: any = {};
    switch (credentials.connection_type) {
      case 'oauth':
        const { oauth } = options;
        const { get_tokens_url_params, get_tokens_set_response } = oauth;
        const secrets = await this.getAuthSecrets(input.plugin);
        if (oauth.content_type === 'application/x-www-form-urlencoded') {
          const requestParams = new URLSearchParams();
          const get_tokens_url_params_string = mustache(get_tokens_url_params, {
            ...secrets,
            ...credentials,
          });
          let get_tokens_url_params_obj: Record<string, any> = {};
          try {
            get_tokens_url_params_obj = JSON.parse(
              get_tokens_url_params_string,
            );
          } catch (error) {
            throw new HttpException(
              'Erro transformando get_tokens_url_params',
              400,
            );
          }
          const { redirect_uri } = get_tokens_url_params_obj;
          for (const key in get_tokens_url_params_obj) {
            const value = get_tokens_url_params_obj[key];
            requestParams.append(key, value);
          }
          const { data } = await axios
            .post(options.oauth.get_tokens_url, requestParams)
            .catch((err) => {
              console.log(err.response.data);
              throw new HttpException(
                err.response.data.message,
                err.response.status,
              );
            });
          for (const key in get_tokens_set_response) {
            const responseKey = get_tokens_set_response[key];
            credentialsTokens[key] = data[responseKey];
          }
          credentialsTokens.redirect_uri = redirect_uri;
        }
        break;
    }
    return { ...credentials, ...credentialsTokens };
  }
  // getOauthTokens(input){

  // }

  async getAvailableEntities(data) {
    console.log('InputClientService', 'GetAvailableEntities');
    objectSnakeToCamel(data);
    const response = await lastValueFrom(
      this.inputService.GetAvailableEntities(data),
    ).catch((err) => {
      console.log(err);
      if (err.details && err.details.includes('400'))
        throw new HttpException('Plugin inválido', HttpStatus.BAD_REQUEST);
      throw new HttpException(err.details, HttpStatus.INTERNAL_SERVER_ERROR);
    });
    objectCamelToSnake(response);

    return response;
  }
}