FEAT: connector manager

src/clients/connector/client.config.ts

@@ -0,0 +1,31 @@
+import { credentials } from '@grpc/grpc-js';
+import { ClientOptions, Transport } from '@nestjs/microservices';
+import { ConnectorManager } from '@victorradael/protospack-v2';
+
+export class ConnectorClientConfiguration {
+  config(): ClientOptions {
+    return {
+      transport: Transport.GRPC,
+      options: {
+        url: process.env.INFACTORY_URL,
+        package: [
+          ConnectorManager.ProtoPackages.WritePackage,
+          ConnectorManager.ProtoPackages.ReadPackage,
+        ],
+        credentials:
+          process.env.LOCAL_ENV === 'local'
+            ? undefined
+            : credentials.createSsl(),
+        protoPath: [
+          ConnectorManager.ProtoPaths.WriteFilePath,
+          ConnectorManager.ProtoPaths.ReadFilePath,
+        ],
+        loader: {
+          enums: String,
+          objects: true,
+          arrays: true,
+        },
+      },
+    };
+  }
+}

src/clients/connector/client.service.ts

@@ -0,0 +1,266 @@
+import {
+  OnModuleInit,
+  Inject,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { ConnectorManager } from '@victorradael/protospack-v2';
+import { from } from 'rxjs';
+
+export class ConnectorClientService implements OnModuleInit {
+  private connectorServiceRead: ConnectorManager.ReadService.ConnectorManagerReadServices;
+  private connectorServiceWrite: ConnectorManager.WriteService.ConnectorManagerWriteServices;
+  constructor(
+    @Inject('CONNECTOR_PACKAGE') private readonly grpcClient: ClientGrpc,
+  ) {}
+
+  onModuleInit() {
+    this.connectorServiceWrite =
+      this.grpcClient.getService<ConnectorManager.WriteService.ConnectorManagerWriteServices>(
+        ConnectorManager.ProtoServices.ConnectorManagerWriteServices,
+      );
+
+    this.connectorServiceRead =
+      this.grpcClient.getService<ConnectorManager.ReadService.ConnectorManagerReadServices>(
+        ConnectorManager.ProtoServices.ConnectorManagerReadServices,
+      );
+  }
+
+  async uploadConnector(uploadConnector) {
+    const connector: ConnectorManager.Entities.ConnectorCreateRequest = {
+      file: {
+        buffer: uploadConnector.file.buffer,
+        mimetypes: uploadConnector.file.mimetype,
+      },
+      connector: JSON.stringify(uploadConnector.connector),
+    };
+    const serviceBody: ConnectorManager.Messages.RegisterConnectorRequest = {
+      connector,
+    };
+
+    const observable = from(
+      this.connectorServiceWrite.RegisterConnector(serviceBody),
+    );
+
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      console.log(err.details);
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'Upload');
+
+    return result;
+  }
+
+  async uploadFile(uploadFile) {
+    const body: ConnectorManager.Messages.UploadFileRequest = {
+      file: {
+        buffer: uploadFile.file.buffer,
+        mimetypes: uploadFile.file.mimetype,
+      },
+      name: uploadFile.name,
+    };
+
+    const observable = from(this.connectorServiceWrite.UploadFile(body));
+
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      console.log(err.details);
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'Upload');
+
+    return result;
+  }
+
+  async getAllConnectors(body) {
+    const observable = from(
+      this.connectorServiceRead.GetAllConnectors({
+        search: body.search,
+        filters: JSON.stringify(body.filters),
+      }),
+    );
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'getAllConnectors');
+
+    return result;
+  }
+
+  async getConnectorDetails(plugin: string) {
+    const observable = from(
+      this.connectorServiceRead.GetConnectorDetails({
+        plugin,
+      }),
+    );
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'getAllConnectors');
+
+    return result;
+  }
+
+  async getConnector(plugin: string) {
+    const observable = from(
+      this.connectorServiceRead.GetConnector({
+        plugin,
+      }),
+    );
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'getAllConnectors');
+
+    return result;
+  }
+
+  async deleteConnector(plugin: string, version: string) {
+    const observable = from(
+      this.connectorServiceWrite.DeleteConnector({
+        version,
+        plugin,
+      }),
+    );
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'getAllConnectors');
+
+    return result;
+  }
+
+  async updateConnector({ plugin, changes }) {
+    const observable = from(
+      this.connectorServiceWrite.UpdateConnector({
+        plugin,
+        changes,
+      }),
+    );
+    const result = await new Promise((resolve, reject) => {
+      observable.subscribe({
+        next(x) {
+          resolve(x);
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    }).catch((err) => {
+      throw new HttpException(
+        err.details,
+        err.code === 6 ? HttpStatus.CONFLICT : 400,
+      );
+    });
+
+    console.log('ConnectorClientService', 'getAllConnectors');
+
+    return result;
+  }
+}