maestro/src/modules/connection-test/connection-test.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { ConnectionTest } from '@dadosfera/protospack-v2';
import { lastValueFrom } from 'rxjs';
import {
  ConnectionTestCredentialsReq,
  ConnectionTestCredentialsRes,
  ConnectionTestListSchemasReq,
  ConnectionTestListSchemasRes,
  ConnectionTestListTablesReq,
  ConnectionTestListTablesRes,
  ConnectionTestPingReq,
  ConnectionTestPingRes,
  GetTableMetadataReq,
  GetTableMetadataRes,
} from './dto/connection-test';
import { ConnectionClientService } from '../connection/client.service';
import {
  CreateConnectionDto,
  DatabaseConnectionPropertiesDto,
} from '../connection/dtos/connection';
import { RequestUser } from 'src/authentication/user.decorator';

@Injectable()
export class ConnectionTestService {
  private connectionTestReadClient: ConnectionTest.ReadService.ConnectionTestReadServices;
  constructor(
    @Inject('ConnectionTestGrpcClient') private readonly grpcClient: ClientGrpc,
    private connectionsService: ConnectionClientService,
  ) {
    this.connectionTestReadClient =
      grpcClient.getService<ConnectionTest.ReadService.ConnectionTestReadServices>(
        ConnectionTest.ProtoServices.ConnectionTestReadServices,
      );
  }

  async connectionTestPing(
    body: ConnectionTestPingReq,
    customer_name: string,
  ): Promise<ConnectionTestPingRes> {
    const { host: endpoint, plugin, port, network_config_id } = body;
    return lastValueFrom(
      this.connectionTestReadClient.ConnectionTestPing({
        customer_name,
        endpoint,
        network_config_id,
        plugin,
        port: port.toString(),
      }),
    );
  }
  async connectionTestCredentials(
    body: ConnectionTestCredentialsReq,
    user: RequestUser,
  ): Promise<ConnectionTestCredentialsRes> {
    const { plugin, ...connectionBody } = body;
    let { connection_id } = body;
    const { customer_id, customer_name, user_id } = user;

    /********* CREATE CONNECTION *********/
    if (!connection_id) {
      const properties: DatabaseConnectionPropertiesDto = {
        ...connectionBody.properties,
        plugin,
        credentials_type: 'basic_auth',
      };
      const createConnectionBody: CreateConnectionDto = {
        ...body,
        properties,
      };
      const { connection } = await this.connectionsService.createConnection(
        createConnectionBody,
        { customer_id, customer_name, user_id },
      );
      connection_id = connection.id;
    }
    /************************************/
    const { operation_result } = await lastValueFrom(
      this.connectionTestReadClient.ConnectionTestCredentials({
        connection_id,
        customer_name,
        plugin,
      }),
    ).catch(async (e) => {
      await this.connectionsService.deleteConnection({
        body: { id: connection_id },
        info: { customer_id, customer_name, user_id },
      });
      throw e;
    });
    if (!operation_result) {
      await this.connectionsService.deleteConnection({
        body: { id: connection_id },
        info: { customer_id, customer_name, user_id },
      });
      connection_id = null;
    }
    return { operation_result, connection_id };
  }
  async connectionTestListSchemas(
    body: ConnectionTestListSchemasReq,
    customer_name: string,
  ): Promise<ConnectionTestListSchemasRes> {
    const { connection_id, plugin } = body;
    return lastValueFrom(
      this.connectionTestReadClient.ListSchemas({
        connection_id,
        customer_name,
        plugin,
      }),
    );
  }
  async connectionTestListTables(
    body: ConnectionTestListTablesReq,
    customer_name: string,
  ): Promise<ConnectionTestListTablesRes> {
    const { connection_id, plugin, schema } = body;
    return lastValueFrom(
      this.connectionTestReadClient.ListTables({
        connection_id,
        customer_name,
        plugin,
        schema,
      }),
    );
  }

  async getTableMetadata(
    body: GetTableMetadataReq,
    customer_name: string,
  ): Promise<GetTableMetadataRes> {
    const { schema, plugin, table_list, connection_id } = body;
    return lastValueFrom(
      this.connectionTestReadClient.GetTableMetadata({
        connection_id,
        customer_name,
        plugin,
        schema,
        table_list,
      }),
    );
  }
}