REFACTOR: Add Auth Validators

src/app.module.ts

@@ -92,11 +92,11 @@ export class AppModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {
     consumer
       .apply(LoggerMiddleware)
-      .forRoutes
-      // InputsController,
-      // TransformationsController,
-      // OutputsController,
-      // PipelinesController,
-      ();
+      .forRoutes(
+        InputsController,
+        TransformationsController,
+        OutputsController,
+        PipelinesController,
+      );
   }
 }

src/clients/inputs/client.service.ts

@@ -1,10 +1,7 @@
-import {
-  OnModuleInit,
-  Inject,
-} from '@nestjs/common';
+import { OnModuleInit, Inject } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 import { InputService } from '@victorradael/protospack';
-import { ICreateInputRequest, IIdRequest, ITestConnectionRequest, UpdateInputRequest } from './interfaces';
+import { IIdRequest, ITestConnectionRequest } from './interfaces';
 
 export class InputsClientService implements OnModuleInit {
   private inputService: InputService;
@@ -12,15 +9,12 @@ export class InputsClientService implements OnModuleInit {
     @Inject('INPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
   ) {}
 
-  
   onModuleInit() {
     this.inputService =
-      this.grpcClient.getService<InputService>(
-        'InputService',
-      );
+      this.grpcClient.getService<InputService>('InputService');
   }
 
-  async create(createInputDto: ICreateInputRequest ) {
+  async create(createInputDto) {
     console.log('InputClientService', 'Create');
 
     const createInputResponse = await new Promise((resolve, reject) => {
@@ -43,17 +37,15 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return createInputResponse;
-    
   }
 
-
-  async findOne(data: IIdRequest ) {
+  async findOne(data: IIdRequest) {
     console.log('InputClientService', 'FindOne');
 
-    const { id } = data
+    const { id } = data;
 
     const findOneInputResponse = await new Promise((resolve, reject) => {
-      this.inputService.FindOne({id}).subscribe({
+      this.inputService.FindOne({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -72,11 +64,9 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return findOneInputResponse;
-    
   }
 
-
-  async findAll(data) {
+  async findAll({}) {
     console.log('InputClientService', 'FindAll');
 
     const findAllInputResponse = await new Promise((resolve, reject) => {
@@ -99,11 +89,9 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return findAllInputResponse;
-    
   }
 
-
-  async update(updateInputDTO:UpdateInputRequest) {
+  async update(updateInputDTO) {
     console.log('InputClientService', 'Update');
     const updateInputResponse = await new Promise((resolve, reject) => {
       this.inputService.Update(updateInputDTO).subscribe({
@@ -125,10 +113,9 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return updateInputResponse;
-    
   }
 
-  async remove(idRequest:IIdRequest) {
+  async remove(idRequest: IIdRequest) {
     console.log('InputClientService', 'Remove');
 
     const removeInputResponse = await new Promise((resolve, reject) => {
@@ -151,10 +138,9 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return removeInputResponse;
-    
   }
 
-  async testConnection(data:ITestConnectionRequest) {
+  async testConnection(data: ITestConnectionRequest) {
     console.log('InputClientService', 'TestCOnnection');
 
     const testConnectionResponse = await new Promise((resolve, reject) => {
@@ -177,7 +163,5 @@ export class InputsClientService implements OnModuleInit {
       });
 
     return testConnectionResponse;
-    
   }
-
 }

src/clients/inputs/interfaces.d.ts

@@ -8,7 +8,7 @@ interface Values {
   engine: string;
   schema: string;
 }
-  
+
 interface Cron {
   hours: string[];
   hour_interval: boolean;
@@ -29,16 +29,14 @@ interface Cron {
 }
 
 export interface ICreateInputRequest {
-
   cron: string;
   name: string;
   plugin: string;
   values: Values;
   operation: string;
-
 }
-export interface IIdRequest{
-  id:string;
+export interface IIdRequest {
+  id: string;
 }
 
 interface UpdateInputRequest {
@@ -53,4 +51,4 @@ interface UpdateInputRequest {
 export interface ITestConnectionRequest {
   plugin: string;
   values: Values;
-} 
+}

src/clients/outputs/client.service.ts

@@ -1,30 +1,26 @@
-import {
-  Controller,
-  Inject,
-  OnModuleInit
-} from '@nestjs/common';
-import {
-  ClientGrpc,
-  Payload,
-} from '@nestjs/microservices';
-import { ApiTags } from '@nestjs/swagger';
+import { Controller, Inject, OnModuleInit } from '@nestjs/common';
+import { ClientGrpc, Payload } from '@nestjs/microservices';
 import { OutputsServiceInterface } from '@victorradael/protospack';
 import { objectCamelToSnake } from 'src/utils/CaseConverter';
-import { ICreateOutputRequest, IIdRequest, IOutputUpdateRequest } from './interfaces';
+import {
+  ICreateOutputRequest,
+  IIdRequest,
+  IOutputUpdateRequest,
+} from './interfaces';
 
 @Controller('output')
 export class OutputsClientService implements OnModuleInit {
   private outputService: OutputsServiceInterface;
   constructor(
-      @Inject('OUTPUTS_PACKAGE')private readonly grpcClient: ClientGrpc,
-  ){}
+    @Inject('OUTPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
+  ) {}
 
   onModuleInit() {
     this.outputService =
       this.grpcClient.getService<OutputsServiceInterface>('OutputService');
   }
 
-  async create(@Payload() createOutputDto:ICreateOutputRequest ) {
+  async create(@Payload() createOutputDto: ICreateOutputRequest) {
     console.log('OutputClientService', 'Create');
 
     const createOutputResponse = await new Promise((resolve, reject) => {
@@ -45,9 +41,9 @@ export class OutputsClientService implements OnModuleInit {
       .catch((err) => {
         throw new Error(err);
       });
-    
-      const convertedItem = objectCamelToSnake(createOutputResponse["output"])
-      createOutputResponse["output"] = convertedItem
+
+    const convertedItem = objectCamelToSnake(createOutputResponse['output']);
+    createOutputResponse['output'] = convertedItem;
     return createOutputResponse;
   }
 
@@ -73,18 +69,18 @@ export class OutputsClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-      const convertedOutputs = findAllOutputResponse['outputs'].map((ot)=>{
-      return objectCamelToSnake(ot)
-    })
+    const convertedOutputs = findAllOutputResponse['outputs'].map((ot) => {
+      return objectCamelToSnake(ot);
+    });
 
-    return {outputs:convertedOutputs};
+    return { outputs: convertedOutputs };
   }
 
-  async findOne({id}: IIdRequest) {
+  async findOne({ id }: IIdRequest) {
     console.log('OutputClientService', 'FindOne');
 
     const findOneOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.FindOne({id}).subscribe({
+      this.outputService.FindOne({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -101,12 +97,10 @@ export class OutputsClientService implements OnModuleInit {
       .catch((err) => {
         throw new Error(err);
       });
-    
-    
+
     return objectCamelToSnake(findOneOutputResponse);
   }
 
-
   async update(updateOutPutDTO: IOutputUpdateRequest) {
     console.log('OutputClientService', 'Update');
 
@@ -128,15 +122,15 @@ export class OutputsClientService implements OnModuleInit {
       .catch((err) => {
         throw new Error(err);
       });
-    
+
     return objectCamelToSnake(updateOutputResponse);
   }
 
-  async remove({id}:IIdRequest) {
+  async remove({ id }: IIdRequest) {
     console.log('OutputClientService', 'Remove');
 
     const removeOutputResponse = await new Promise((resolve, reject) => {
-      this.outputService.Remove({id}).subscribe({
+      this.outputService.Remove({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -154,6 +148,6 @@ export class OutputsClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-    return removeOutputResponse;  
+    return removeOutputResponse;
   }
 }

src/clients/outputs/interfaces.d.ts

@@ -1,22 +1,22 @@
 export interface ICreateOutputRequest {
-    operation: string;
-    name: string;
-    plugin: string;
-    values: Values;
+  operation: string;
+  name: string;
+  plugin: string;
+  values: Values;
 }
 
 export interface Values {
-    prefix: string;
+  prefix: string;
 }
 
-export interface IIdRequest{
-    id:string;
+export interface IIdRequest {
+  id: string;
 }
 
 export interface IOutputUpdateRequest {
-    id: string;
-    operation: string;
-    values: Values;
-    plugin: string;
-    name: string;
-}
+  id: string;
+  operation: string;
+  values: Values;
+  plugin: string;
+  name: string;
+}

src/clients/pipelines/client.config.ts

@@ -19,4 +19,4 @@ export class PipelinesClientConfiguration {
       },
     };
   }
-};
+}

src/clients/pipelines/client.service.ts

@@ -1,38 +1,25 @@
-import {
-  Controller,
-  Delete,
-  Get,
-  Inject,
-  OnModuleInit,
-  Param,
-  Post,
-  Put,
-} from '@nestjs/common';
-import {
-  Client,
-  ClientGrpc,
-  MessagePattern,
-  Payload,
-} from '@nestjs/microservices';
+import { Inject, OnModuleInit } from '@nestjs/common';
+import { ClientGrpc, Payload } from '@nestjs/microservices';
 import { PipelinesServiceInterface } from '@victorradael/protospack';
-import { ICreatePipelineDto, IdRequest, IGetPipelineLogsRequest, IUpdatePipelineRequest } from './interfaces';
+import {
+  ICreatePipelineDto,
+  IdRequest,
+  IGetPipelineLogsRequest,
+  IUpdatePipelineRequest,
+} from './interfaces';
 
 export class PipelinesClientService implements OnModuleInit {
   private pipelineService: PipelinesServiceInterface;
   constructor(
-      @Inject('PIPELINES_PACKAGE') private readonly grpcClient: ClientGrpc,
-  ){}
+    @Inject('PIPELINES_PACKAGE') private readonly grpcClient: ClientGrpc,
+  ) {}
 
   onModuleInit() {
     this.pipelineService =
-      this.grpcClient.getService<PipelinesServiceInterface>(
-        'PipelineService',
-      );
+      this.grpcClient.getService<PipelinesServiceInterface>('PipelineService');
   }
 
-
-  async create(@Payload() createPipelineDto: ICreatePipelineDto ) {
-
+  async create(@Payload() createPipelineDto: ICreatePipelineDto) {
     console.log('PipelinesClientService', 'Create');
 
     const createPipelineResponse = await new Promise((resolve, reject) => {
@@ -55,7 +42,6 @@ export class PipelinesClientService implements OnModuleInit {
       });
 
     return createPipelineResponse;
-    
   }
 
   async findAll() {
@@ -83,11 +69,11 @@ export class PipelinesClientService implements OnModuleInit {
     return findAllPipelineResponse;
   }
 
-  async findOne({id}: IdRequest) {
+  async findOne({ id }: IdRequest) {
     console.log('PipelinesClientService', 'FindOne');
 
     const findOnePipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.findOne({id}).subscribe({
+      this.pipelineService.findOne({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -108,7 +94,7 @@ export class PipelinesClientService implements OnModuleInit {
     return findOnePipelineResponse;
   }
 
-  async update(UpdatePipelineRequest:IUpdatePipelineRequest) {
+  async update(UpdatePipelineRequest: IUpdatePipelineRequest) {
     console.log('PipelinesClientService', 'Update');
 
     const updatePipelineResponse = await new Promise((resolve, reject) => {
@@ -130,15 +116,14 @@ export class PipelinesClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-    return updatePipelineResponse; 
+    return updatePipelineResponse;
   }
 
-
-  async remove({id}:IdRequest) {
+  async remove({ id }: IdRequest) {
     console.log('PipelinesClientService', 'Remove');
 
     const removePipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.remove({id}).subscribe({
+      this.pipelineService.remove({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -156,10 +141,10 @@ export class PipelinesClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-    return removePipelineResponse; 
+    return removePipelineResponse;
   }
 
-  async getPipelineLogsMessages( data:IGetPipelineLogsRequest) {
+  async getPipelineLogsMessages(data: IGetPipelineLogsRequest) {
     console.log('PipelinesClientService', 'GetPipelineLogsMessages');
 
     const logsPipelineResponse = await new Promise((resolve, reject) => {
@@ -181,14 +166,14 @@ export class PipelinesClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-    return logsPipelineResponse; 
+    return logsPipelineResponse;
   }
 
-  async getPipelineStatus({id}:IdRequest) {
+  async getPipelineStatus({ id }: IdRequest) {
     console.log('PipelinesClientService', 'GetPipelineStatus');
 
     const statusPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.getPipelineStatus({id}).subscribe({
+      this.pipelineService.getPipelineStatus({ id }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -206,6 +191,6 @@ export class PipelinesClientService implements OnModuleInit {
         throw new Error(err);
       });
 
-    return statusPipelineResponse; 
+    return statusPipelineResponse;
   }
 }

src/clients/pipelines/interfaces.d.ts

@@ -1,28 +1,27 @@
-
 export interface ICreatePipelineDto {
-    input: IdRequest;
-    transformations: IdRequest[];
-    output: IdRequest;
-    tags: string[];
-    name: string;
-    description: string;
+  input: IdRequest;
+  transformations: IdRequest[];
+  output: IdRequest;
+  tags: string[];
+  name: string;
+  description: string;
 }
 
 export interface IdRequest {
-    id: string;
+  id: string;
 }
 
 export interface IUpdatePipelineRequest {
-    input: IdRequest;
-    transformations: IdRequest[];
-    output: IdRequest;
-    tags: string[];
-    name: string;
-    description: string;
-    id: string;
+  input: IdRequest;
+  transformations: IdRequest[];
+  output: IdRequest;
+  tags: string[];
+  name: string;
+  description: string;
+  id: string;
 }
 
 export interface IGetPipelineLogsRequest {
-    id: string;
-    details: string;
-}
+  id: string;
+  details: string;
+}

src/clients/transformations/client.config.ts

@@ -19,4 +19,4 @@ export class TransformationsClientConfiguration {
       },
     };
   }
-};
+}

src/clients/transformations/client.service.ts

@@ -1,23 +1,8 @@
-import {
-  Controller,
-  Delete,
-  Get,
-  Inject,
-  OnModuleInit,
-  Param,
-  Post,
-  Put,
-} from '@nestjs/common';
-import {
-  Client,
-  ClientGrpc,
-  MessagePattern,
-  Payload,
-} from '@nestjs/microservices';
-import { ApiTags } from '@nestjs/swagger';
+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 { Transformation, ICreateTransformationsRequest, IdRequest, IUpdateTransformationRequest } from './interfaces';
+import { ICreateTransformationsRequest, IdRequest } from './interfaces';
 
 @Controller('transformation')
 export class TransformationsClientService implements OnModuleInit {
@@ -37,76 +22,86 @@ export class TransformationsClientService implements OnModuleInit {
   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');
-        },
-      });
-    })
+    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)
-      })
+    const convertedTransforms = createTransformationResponse[
+      'transformations'
+    ].map((tr) => {
+      return objectCamelToSnake(tr);
+    });
 
-    return {transformations:convertedTransforms};
+    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');
-        },
-      });
-    })
+    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};
+    const convertedTransforms = findAllTransformationResponse[
+      'transformations'
+    ].map((tr) => {
+      return objectCamelToSnake(tr);
+    });
+    return { transformations: convertedTransforms };
   }
 
-  async findOne({id}: IdRequest) {
+  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');
-        },
-      });
-    })
+    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);
@@ -115,48 +110,52 @@ export class TransformationsClientService implements OnModuleInit {
     return objectCamelToSnake(findOneTransformationResponse);
   }
 
-  async update(updateTransformationDTO: IUpdateTransformationRequest) {
+  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');
-        },
-      });
-    })
+    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);
+    return objectCamelToSnake(updateTransformationResponse);
   }
 
-  async remove({id}: IdRequest) {
+  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');
-        },
-      });
-    })
+    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);

src/clients/transformations/interfaces.d.ts

@@ -1,28 +1,28 @@
 export interface ICreateTransformationsRequest {
-    transformations: Transformation[];
+  transformations: Transformation[];
 }
 interface Param {
-    base_column: string;
-    column_name: string;
-    n_digits: number;
-    start_index: number;
-    randbelow: number;
-    const: string;
+  base_column: string;
+  column_name: string;
+  n_digits: number;
+  start_index: number;
+  randbelow: number;
+  const: string;
 }
 interface Transformation {
-    created_at: string;
-    id: string;
-    client_id: string;
-    type: string;
-    params: Param[];
-    input_source: string;
-    table: string;
+  created_at: string;
+  id: string;
+  client_id: string;
+  type: string;
+  params: Param[];
+  input_source: string;
+  table: string;
 }
 
-export interface IdRequest{
-    id:string;
+export interface IdRequest {
+  id: string;
 }
 
 export interface IUpdateTransformationRequest {
-    transformation: Transformation;
-}
+  transformation: Transformation;
+}

src/error/http-exception.filter.spec.ts

@@ -0,0 +1,7 @@
+import { HttpExceptionFilter } from './http-exception.filter';
+
+describe('HttpExceptionFilter', () => {
+  it('should be defined', () => {
+    expect(new HttpExceptionFilter()).toBeDefined();
+  });
+});

src/error/http-exception.filter.ts

@@ -0,0 +1,24 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+    const status = exception.getStatus();
+
+    response.status(status).json({
+      status_code: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+    });
+  }
+}

src/middlewares/authentication.ts

@@ -1,23 +1,120 @@
 import { Request, Response, NextFunction } from 'express';
 import axios from 'axios';
-import { NestMiddleware } from '@nestjs/common';
+import {
+  ForbiddenException,
+  InternalServerErrorException,
+  NestMiddleware,
+  UnauthorizedException,
+  UseFilters,
+} from '@nestjs/common';
+import jwkToPem from 'jwk-to-pem';
+import { decode, verify } from 'jsonwebtoken';
+import { HttpExceptionFilter } from 'src/error/http-exception.filter';
 
+@UseFilters(new HttpExceptionFilter())
 export class LoggerMiddleware implements NestMiddleware {
   use = async (request: Request, response: Response, next: NextFunction) => {
-    try {
-      const verify_response = await axios
-        .post(`${process.env.DEV_URL}/user/verify`, {
-          token: request.get('Authorization'),
-        })
-        .then((response) => {
-          if (response.data.message == 'Success') {
-            next();
-          }
-        });
+    const idToken = request.get('User-Agent');
+    const accessToken = request.get('Authorization');
+    const privateKey = process.env.JWT_PRIVATE_KEY;
 
-      console.log(verify_response);
-    } catch (error) {
-      response.status(401).send({ message: 'Authentication Failed!' });
+    const requiredMethod = request.method.trim();
+    const requiredRoute = request.route.path.split('/')[1].trim();
+
+    verify(idToken, privateKey, (err) => {
+      if (err) {
+        throw new UnauthorizedException();
+      }
+    });
+    const jwtDecoded: any = decode(idToken);
+    console.log(jwtDecoded);
+    const permissions = jwtDecoded.user.permissions;
+    const clienId = jwtDecoded.user.customerId;
+    const userId = jwtDecoded.user.id;
+
+    await verifyToken(accessToken);
+
+    let havePermission = false;
+    permissions.forEach((permission) => {
+      permission = permission.split('/');
+      const method = permission[0].trim();
+      const route = permission[1].trim();
+
+      if (method === requiredMethod && route === requiredRoute) {
+        havePermission = true;
+      }
+    });
+
+    if (havePermission) {
+      request.body.client_id = clienId;
+      request.body.user_id = userId;
+      next();
+    } else {
+      throw new ForbiddenException();
     }
   };
 }
+
+let pems: { [key: string]: Record<string, unknown> }[];
+
+const setUp = async (region: string, id: string) => {
+  const URL = `https://cognito-idp.${region}.amazonaws.com/${id}/.well-known/jwks.json`;
+
+  try {
+    const response = await axios.get(URL);
+
+    if (response.status !== 200) {
+      throw new InternalServerErrorException();
+    }
+    const data = await response.data;
+    const { keys } = data;
+
+    pems = keys.map((key: any) => {
+      const modulus = key.n;
+      const exponent = key.e;
+      const keyType = key.kty;
+      const jwk = { kty: keyType, n: modulus, e: exponent };
+      const pem = jwkToPem(jwk);
+      const keyId = key.kid;
+
+      return { [keyId]: pem };
+    });
+  } catch (error) {
+    // console.log(error);
+    // console.log('Error! Unable to download JWKs');
+  }
+};
+
+const verifyToken = async (accessToken: string) => {
+  const awsRegion = process.env.AWS_REGION;
+  const awsPoolId = process.env.AWS_IDENTITY_POOL_ID;
+
+  try {
+    await setUp(awsRegion, awsPoolId);
+    if (accessToken) {
+      const user: any = decode(accessToken, { complete: true });
+
+      if (user === null) {
+        throw new UnauthorizedException();
+      }
+
+      const { kid } = user.header;
+      const pem = pems.filter((item: any) => item[kid]);
+      const pemValue: any = pem[0][kid];
+
+      if (!pem) {
+        throw new UnauthorizedException();
+      }
+
+      verify(accessToken, pemValue, (err: any) => {
+        if (err) {
+          throw new UnauthorizedException();
+        }
+
+        return;
+      });
+    }
+  } catch (error) {
+    throw new UnauthorizedException();
+  }
+};

src/modules/inputs/inputs.controller.ts

@@ -7,15 +7,13 @@ import {
   Post,
   Put,
 } from '@nestjs/common';
-import axios from 'axios';
 import { InputsService } from './inputs.service';
 import { InputsClientService } from 'src/clients/inputs/client.service';
 import { Payload } from '@nestjs/microservices';
 
-@Controller('input')
+@Controller('inputs')
 export class InputsController {
-
-    constructor( private inputsClientService:InputsClientService){}
+  constructor(private inputsClientService: InputsClientService) {}
 
   @Get('/test-connection')
   async testConnection(@Body() data) {
@@ -23,11 +21,11 @@ export class InputsController {
       process.env.DEV_URL + `/test-connection`,
       'ON TEST CONNECTION ROUTE',
     );
-    
-    console.log(data)
 
-    const inputService = new InputsService(this.inputsClientService)
-    const response = await inputService.testConnection(data)
+    console.log(data);
+
+    const inputService = new InputsService(this.inputsClientService);
+    const response = await inputService.testConnection(data);
 
     return response;
   }
@@ -36,8 +34,8 @@ export class InputsController {
   async create(@Body() createInputDto) {
     console.log(process.env.DEV_URL + `/input`, 'ON CREATE ROUTE');
 
-    const inputService = new InputsService(this.inputsClientService)
-    const response = await inputService.create(createInputDto)
+    const inputService = new InputsService(this.inputsClientService);
+    const response = await inputService.create(createInputDto);
 
     return response;
   }
@@ -46,53 +44,46 @@ export class InputsController {
   async findAll() {
     console.log(process.env.DEV_URL + `/input`, 'ON FIND ALL ROUTE');
 
-    const inputService = new InputsService(this.inputsClientService)
+    const inputService = new InputsService(this.inputsClientService);
 
-    const response = await inputService.findAll()
+    const response = await inputService.findAll();
 
     return response;
   }
 
   @Get('/:id')
   async findOne(@Param() params) {
-    const { id } = params
+    const { id } = params;
     console.log(process.env.DEV_URL + `/input/${id}`, 'ON FIND ONE ROUTE');
-    const inputService = new InputsService(this.inputsClientService)
-    
-    const response = await inputService.findOne(id)
+    const inputService = new InputsService(this.inputsClientService);
+
+    const response = await inputService.findOne(id);
 
     return response;
   }
 
-
   @Put(':id')
-  async update(
-    @Payload() updateInputDto,
-    @Param() params,
-  ) {
-    
-    const {id} = params;
+  async update(@Payload() updateInputDto, @Param() params) {
+    const { id } = params;
 
     console.log(process.env.DEV_URL + `/input/${id}`, 'ON UPDATE ROUTE');
-    const inputService = new InputsService(this.inputsClientService)
+    const inputService = new InputsService(this.inputsClientService);
 
-    const response = await inputService.update(id,updateInputDto)
+    const response = await inputService.update(id, updateInputDto);
 
     return response;
   }
 
   @Delete(':id')
   async delete(@Param() params) {
+    const { id } = params;
 
-    const {id} = params
-    
     console.log(process.env.DEV_URL + `/input/${id}`, 'ON DELETE ROUTE');
 
-    const inputService = new InputsService(this.inputsClientService)
+    const inputService = new InputsService(this.inputsClientService);
 
-    const response = await inputService.remove(id)
+    const response = await inputService.remove(id);
 
     return response;
-
   }
 }

src/modules/inputs/inputs.service.ts

@@ -3,85 +3,69 @@ import { InputsClientService } from 'src/clients/inputs/client.service';
 
 @Injectable()
 export class InputsService {
+  constructor(private inputClient: InputsClientService) {}
 
-  constructor( private inputClient: InputsClientService){}
+  async create(data) {
+    try {
+      const createInputResponse = await this.inputClient.create(data);
 
-
-  async create(data){
-
-    try{
-    
-      const createInputResponse = await this.inputClient.create(data)
-      
       return createInputResponse;
-    
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
-
   }
 
-  async findAll(){
+  async findAll() {
+    try {
+      const findAllInputResponse = await this.inputClient.findAll({});
 
-    try{
-      
-      const findAllInputResponse = await this.inputClient.findAll({})
-      
       return findAllInputResponse;
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
-
   }
 
-  async findOne(id:string){
-
-    try{
-      
-      const findOneInputResponse = await this.inputClient.findOne({id})
+  async findOne(id: string) {
+    try {
+      const findOneInputResponse = await this.inputClient.findOne({ id });
       return findOneInputResponse;
-    
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async update(id:string,data){
+  async update(id: string, data) {
+    try {
+      const updateInputResponse = await this.inputClient.update({
+        id,
+        ...data,
+      });
 
-    try{
-      
-      const updateInputResponse = await this.inputClient.update({id,...data})
-      
       return updateInputResponse;
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async remove(id:string){
+  async remove(id: string) {
+    try {
+      const removeInputResponse = await this.inputClient.remove({ id });
 
-    try{
-      const removeInputResponse = await this.inputClient.remove({id})
-      
       return removeInputResponse;
-    
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async testConnection(data){
+  async testConnection(data) {
+    try {
+      const testConnectionInputResponse = await this.inputClient.testConnection(
+        data,
+      );
 
-    try{
-
-      const testConnectionInputResponse = await this.inputClient.testConnection(data)
-      
       return testConnectionInputResponse;
-    
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 }

src/modules/pipelines/pipelines.controller.ts

@@ -6,53 +6,49 @@ import {
   Param,
   Post,
   Put,
-  Redirect,
 } from '@nestjs/common';
 import { Payload } from '@nestjs/microservices';
 import { PipelinesClientService } from 'src/clients/pipelines/client.service';
-import { objectCamelToSnake } from 'src/utils/CaseConverter';
 import { PipelinesService } from './pipelines.service';
 
 @Controller('pipelines')
 export class PipelinesController {
-
-  constructor( private pipelinesClientService:PipelinesClientService){}
+  constructor(private pipelinesClientService: PipelinesClientService) {}
 
   @Get(':id/status')
-  async getPipelineStatus(
-    @Param() params,
-  ) {
-    const { id , details } = params;
-    console.log(process.env.DEV_URL + `/pipeline/${id}`, 'ON GET PIPELINE STATUS ROUTE');
+  async getPipelineStatus(@Param() params) {
+    const { id } = params;
+    console.log(
+      process.env.DEV_URL + `/pipeline/${id}`,
+      'ON GET PIPELINE STATUS ROUTE',
+    );
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.getPipelineStatus(id)
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.getPipelineStatus(id);
 
     return response;
-
   }
 
-
   @Get(':id/:details')
-  async getPipelineLogs(
-    @Param() params,
-  ) {
-    const { id , details } = params;
-    console.log(process.env.DEV_URL + `/pipeline/${id}`, 'ON GET PIPELINE LOGS ROUTE');
+  async getPipelineLogs(@Param() params) {
+    const { id, details } = params;
+    console.log(
+      process.env.DEV_URL + `/pipeline/${id}`,
+      'ON GET PIPELINE LOGS ROUTE',
+    );
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.getPipelineLogsMessages(id,details)
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.getPipelineLogsMessages(id, details);
 
     return response;
-
   }
 
   @Post()
   async create(@Body() createPipelineDto) {
     console.log(process.env.DEV_URL + `/pipelines`, 'ON CREATE ROUTE');
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.create(createPipelineDto)
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.create(createPipelineDto);
 
     return response;
   }
@@ -61,49 +57,42 @@ export class PipelinesController {
   async findAll() {
     console.log(process.env.DEV_URL + `/pipeline`, 'ON Find All ROUTE');
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.findAll()
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.findAll();
 
     return response;
-
   }
 
   @Get('/:id')
   async findOne(@Param() params) {
-    const {id} = params;
+    const { id } = params;
     console.log(process.env.DEV_URL + `/pipeline/${id}`, 'ON Find One ROUTE');
-    
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.findOne(id)
+
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.findOne(id);
 
     return response;
   }
 
   @Put(':id')
-  async update(
-    @Payload() updatePipelineDto,
-    @Param() params,
-  ) {
-    const {id} = params;
+  async update(@Payload() updatePipelineDto, @Param() params) {
+    const { id } = params;
     console.log(process.env.DEV_URL + `/pipeline/${id}`, 'ON UPDATE ROUTE');
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.update(id,updatePipelineDto)
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.update(id, updatePipelineDto);
 
     return response;
-
   }
 
   @Delete(':id')
   async delete(@Param() params) {
-    const {id} = params;
+    const { id } = params;
     console.log(process.env.DEV_URL + `/pipeline/${id}`, 'ON DELETE ROUTE');
 
-    const pipelineService = new PipelinesService(this.pipelinesClientService)
-    const response = await pipelineService.remove(id)
+    const pipelineService = new PipelinesService(this.pipelinesClientService);
+    const response = await pipelineService.remove(id);
 
     return response;
   }
-
-
 }

src/modules/pipelines/pipelines.service.ts

@@ -4,96 +4,82 @@ import { objectCamelToSnake } from 'src/utils/CaseConverter';
 
 @Injectable()
 export class PipelinesService {
+  constructor(private pipelineClient: PipelinesClientService) {}
 
-  constructor( private pipelineClient: PipelinesClientService){}
+  async create(createPipelineDto) {
+    try {
+      const createPipelineResponse = await this.pipelineClient.create(
+        createPipelineDto,
+      );
 
-  async create(createPipelineDto){
-    try{
-      const createPipelineResponse = await this.pipelineClient.create(createPipelineDto);
-  
-      return objectCamelToSnake(createPipelineResponse) 
-
-    }catch(err){
-      console.log(err)
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return objectCamelToSnake(createPipelineResponse);
+    } catch (err) {
+      console.log(err);
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
-
   }
 
-  async findOne(id:string){
-    
-    try{
-      const findOnePipelineResponse = await this.pipelineClient.findOne({id});
-      return objectCamelToSnake(findOnePipelineResponse)
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+  async findOne(id: string) {
+    try {
+      const findOnePipelineResponse = await this.pipelineClient.findOne({ id });
+      return objectCamelToSnake(findOnePipelineResponse);
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
-
   }
 
-  async findAll(){
-    
-    try{
+  async findAll() {
+    try {
       const findAllPipelineResponse = await this.pipelineClient.findAll();
-  
-      return objectCamelToSnake(findAllPipelineResponse)
 
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return objectCamelToSnake(findAllPipelineResponse);
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async update(id:string, data){
+  async update(id: string, data) {
+    try {
+      const updatePipelineResponse = await this.pipelineClient.update({
+        id,
+        ...data,
+      });
 
-    try{    
-
-      const updatePipelineResponse = await this.pipelineClient.update({id,...data});
-  
-      return objectCamelToSnake(updatePipelineResponse)
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return objectCamelToSnake(updatePipelineResponse);
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async remove(id:string){
+  async remove(id: string) {
+    try {
+      const removePipelineResponse = await this.pipelineClient.remove({ id });
 
-    try{    
-
-      const removePipelineResponse = await this.pipelineClient.remove({id});
-  
-      return removePipelineResponse
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return removePipelineResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
+  async getPipelineLogsMessages(id: string, details: string) {
+    try {
+      const pipelineLogsResponse =
+        await this.pipelineClient.getPipelineLogsMessages({ id, details });
 
-  async getPipelineLogsMessages(id:string,details:string){
-
-    try{    
-
-        const pipelineLogsResponse = await this.pipelineClient.getPipelineLogsMessages({id,details});
-    
-        return objectCamelToSnake(pipelineLogsResponse)
-  
-      }catch(err){
-        throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return objectCamelToSnake(pipelineLogsResponse);
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async getPipelineStatus(id:string){
+  async getPipelineStatus(id: string) {
+    try {
+      const pipelineStatusResponse =
+        await this.pipelineClient.getPipelineStatus({ id });
 
-    try{    
-
-        const pipelineStatusResponse = await this.pipelineClient.getPipelineStatus({id});
-    
-        return objectCamelToSnake(pipelineStatusResponse)
-  
-      }catch(err){
-        throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return objectCamelToSnake(pipelineStatusResponse);
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
-
 }

src/modules/transformations/transformations.controller.ts

@@ -6,7 +6,6 @@ import {
   Param,
   Post,
   Put,
-  Redirect,
 } from '@nestjs/common';
 import { Payload } from '@nestjs/microservices';
 import { TransformationsClientService } from 'src/clients/transformations/client.service';
@@ -14,66 +13,84 @@ import { TransformationsService } from './transformations.service';
 
 @Controller('transformations')
 export class TransformationsController {
+  constructor(
+    private transformationsClientService: TransformationsClientService,
+  ) {}
 
-    constructor( private transformationsClientService:TransformationsClientService){}
+  @Post()
+  async create(@Body() createTransformationDto) {
+    console.log(process.env.DEV_URL + `/transformation`, 'ON CREATE ROUTE');
 
+    const transformationService = new TransformationsService(
+      this.transformationsClientService,
+    );
+    const response = await transformationService.create(
+      createTransformationDto,
+    );
 
-    @Post()
-    async create(@Body() createTransformationDto) {
-      console.log(process.env.DEV_URL + `/transformation`, 'ON CREATE ROUTE');
-      
-      const transformationService = new TransformationsService(this.transformationsClientService)
-      const response = await transformationService.create(createTransformationDto)
-  
-      return response;
-    }
-  
-    @Get()
-    async findAll() {
-      console.log(process.env.DEV_URL + `/transformation`, 'ON Find All ROUTE');
-  
-      const transformationService = new TransformationsService(this.transformationsClientService)
-      const response = await transformationService.findAll()
-  
-      return response;
-  
-    }
-  
-    @Get('/:id')
-    async findOne(@Param() params) {
-      const {id} = params;
-      console.log(process.env.DEV_URL + `/transformation/${id}`, 'ON Find One ROUTE');
-      
-      const transformationService = new TransformationsService(this.transformationsClientService)
-      const response = await transformationService.findOne(id)
-  
-      return response;
-    }
-  
-    @Put(':id')
-    async update(
-      @Payload() updateTransformationDto,
-      @Param() params,
-    ) {
-      const {id} = params;
-      console.log(process.env.DEV_URL + `/transformation/${id}`, 'ON UPDATE ROUTE');
-  
-      const transformationService = new TransformationsService(this.transformationsClientService)
-      const response = await transformationService.update(id,updateTransformationDto)
-  
-      return response;
-  
-    }
-  
-    @Delete(':id')
-    async delete(@Param() params) {
-      const {id} = params;
-      console.log(process.env.DEV_URL + `/transformation/${id}`, 'ON DELETE ROUTE');
-  
-      const transformationService = new TransformationsService(this.transformationsClientService)
-      const response = await transformationService.remove(id)
-  
-      return response;
-    }
-  
+    return response;
+  }
+
+  @Get()
+  async findAll() {
+    console.log(process.env.DEV_URL + `/transformation`, 'ON Find All ROUTE');
+
+    const transformationService = new TransformationsService(
+      this.transformationsClientService,
+    );
+    const response = await transformationService.findAll();
+
+    return response;
+  }
+
+  @Get('/:id')
+  async findOne(@Param() params) {
+    const { id } = params;
+    console.log(
+      process.env.DEV_URL + `/transformation/${id}`,
+      'ON Find One ROUTE',
+    );
+
+    const transformationService = new TransformationsService(
+      this.transformationsClientService,
+    );
+    const response = await transformationService.findOne(id);
+
+    return response;
+  }
+
+  @Put(':id')
+  async update(@Payload() updateTransformationDto, @Param() params) {
+    const { id } = params;
+    console.log(
+      process.env.DEV_URL + `/transformation/${id}`,
+      'ON UPDATE ROUTE',
+    );
+
+    const transformationService = new TransformationsService(
+      this.transformationsClientService,
+    );
+    const response = await transformationService.update(
+      id,
+      updateTransformationDto,
+    );
+
+    return response;
+  }
+
+  @Delete(':id')
+  async delete(@Param() params) {
+    const { id } = params;
+    console.log(
+      process.env.DEV_URL + `/transformation/${id}`,
+      'ON DELETE ROUTE',
+    );
+
+    const transformationService = new TransformationsService(
+      this.transformationsClientService,
+    );
+    const response = await transformationService.remove(id);
+
+    return response;
+  }
 }

src/modules/transformations/transformations.service.ts

@@ -5,73 +5,66 @@ import { trSnakeToCamel } from 'src/utils/CaseConverter';
 
 @Injectable()
 export class TransformationsService {
+  constructor(private transformationClient: TransformationsClientService) {}
 
-  constructor( private transformationClient: TransformationsClientService){}
+  async create(createTransformationDto: ICreateTransformationsRequest) {
+    try {
+      const convertedDTO = createTransformationDto.transformations.map((tr) => {
+        return trSnakeToCamel(tr);
+      });
 
-  async create(createTransformationDto:ICreateTransformationsRequest){
-    try{
+      const createTransformationResponse =
+        await this.transformationClient.create({
+          transformations: convertedDTO,
+        });
 
-      let convertedDTO = createTransformationDto.transformations.map((tr)=>{
-
-        return trSnakeToCamel(tr)
-      })
-
-      const createTransformationResponse = await this.transformationClient.create({transformations:convertedDTO});
-  
-      return createTransformationResponse
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
-    }
-
-  }
-
-  async findOne(id:string){
-    
-    try{
-      const findOneTransformationResponse = await this.transformationClient.findOne({id});
-      return findOneTransformationResponse
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
-    }
-
-  }
-
-  async findAll(){
-    
-    try{
-      const findAllTransformationResponse = await this.transformationClient.findAll();
-  
-      return findAllTransformationResponse
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return createTransformationResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async update(id:string, data){
-
-    try{    
-      data.transformation["id"] = id 
-      const updateTransformationResponse = await this.transformationClient.update({...data});
-  
-      return updateTransformationResponse
-
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+  async findOne(id: string) {
+    try {
+      const findOneTransformationResponse =
+        await this.transformationClient.findOne({ id });
+      return findOneTransformationResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 
-  async remove(id:string){
+  async findAll() {
+    try {
+      const findAllTransformationResponse =
+        await this.transformationClient.findAll();
 
-    try{    
+      return findAllTransformationResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
+    }
+  }
 
-      const removeTransformationResponse = await this.transformationClient.remove({id});
-  
-      return removeTransformationResponse
+  async update(id: string, data) {
+    try {
+      data.transformation['id'] = id;
+      const updateTransformationResponse =
+        await this.transformationClient.update({ ...data });
 
-    }catch(err){
-      throw new HttpException(err.message,HttpStatus.NOT_FOUND)
+      return updateTransformationResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
+    }
+  }
+
+  async remove(id: string) {
+    try {
+      const removeTransformationResponse =
+        await this.transformationClient.remove({ id });
+
+      return removeTransformationResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
 }

src/utils/Authenticate.ts

@@ -1,20 +0,0 @@
-import axios from 'axios';
-
-export class AuthenticateController {
-  private username: string;
-  private password: string;
-
-  constructor() {
-    this.username = process.env.AUTH_USERNAME;
-    this.password = process.env.AUTH_PASSWORD;
-  }
-
-  async authenticate(): Promise<string> {
-    const response = await axios.post(process.env.AUTH_ROUTE, {
-      username: this.username,
-      password: this.password,
-    });
-
-    return response.data.accessToken;
-  }
-}

src/utils/CaseConverter.ts

@@ -5,7 +5,7 @@ export const objectCamelToSnake = (object) => {
   const newKeys = objectKeys.map((key) => {
     return key
       .split(/(?=[A-Z])/)
-      .join("_")
+      .join('_')
       .toLowerCase();
   });
 
@@ -17,7 +17,7 @@ export const objectCamelToSnake = (object) => {
   });
 
   objectValues.forEach((value) => {
-    if (typeof value === "object") {
+    if (typeof value === 'object') {
       objectCamelToSnake(value);
     }
   });
@@ -31,7 +31,7 @@ export const objectSnakeToCamel = (object) => {
 
   const newKeys = objectKeys.map((key) => {
     return key.replace(/([-_][a-z])/gi, ($1) => {
-      return $1.toUpperCase().replace("-", "").replace("_", "");
+      return $1.toUpperCase().replace('-', '').replace('_', '');
     });
   });
 
@@ -43,22 +43,20 @@ export const objectSnakeToCamel = (object) => {
   });
 
   objectValues.forEach((value) => {
-    if (typeof value === "object") {
+    if (typeof value === 'object') {
       objectSnakeToCamel(value);
     }
   });
 
   return object;
 };
-  
-  export const trSnakeToCamel = (object) =>{
 
-    const convertedParams = object.params.map((param)=>{
-      return objectSnakeToCamel(param)
-    })
+export const trSnakeToCamel = (object) => {
+  const convertedParams = object.params.map((param) => {
+    return objectSnakeToCamel(param);
+  });
 
-    object.params = convertedParams
+  object.params = convertedParams;
 
-    return objectSnakeToCamel(object)
-
-  }
+  return objectSnakeToCamel(object);
+};

swagger.json

@@ -1 +1 @@
-{"openapi":"3.0.0","paths":{"/input/test-connection":{"get":{"operationId":"InputsController_testConnection","parameters":[],"responses":{"200":{"description":""}}}},"/input":{"post":{"operationId":"InputsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"InputsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/input/{id}":{"get":{"operationId":"InputsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"InputsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"InputsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/transformations":{"post":{"operationId":"TransformationsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"TransformationsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/transformations/{id}":{"get":{"operationId":"TransformationsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"TransformationsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"TransformationsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/outputs":{"post":{"operationId":"OutputsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"OutputsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/outputs/{id}":{"get":{"operationId":"OutputsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"OutputsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"OutputsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}/status":{"get":{"operationId":"PipelinesController_getPipelineStatus","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}/{details}":{"get":{"operationId":"PipelinesController_getPipelineLogs","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines":{"post":{"operationId":"PipelinesController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"PipelinesController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}":{"get":{"operationId":"PipelinesController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"PipelinesController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"PipelinesController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/auth":{"post":{"operationId":"AuthController_signIn","parameters":[],"responses":{"201":{"description":""}}}},"/health":{"get":{"operationId":"HealthController_check","parameters":[],"responses":{"200":{"description":""}}}}},"info":{"title":"Maestro Grpc Documentation","description":"Documentation for Maestro gateway","version":"1.0","contact":{}},"tags":[],"servers":[],"components":{"securitySchemes":{"bearer":{"scheme":"bearer","bearerFormat":"JWT","type":"http"}},"schemas":{}}}
+{"openapi":"3.0.0","paths":{"/inputs/test-connection":{"get":{"operationId":"InputsController_testConnection","parameters":[],"responses":{"200":{"description":""}}}},"/inputs":{"post":{"operationId":"InputsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"InputsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/inputs/{id}":{"get":{"operationId":"InputsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"InputsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"InputsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/transformations":{"post":{"operationId":"TransformationsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"TransformationsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/transformations/{id}":{"get":{"operationId":"TransformationsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"TransformationsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"TransformationsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/outputs":{"post":{"operationId":"OutputsController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"OutputsController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/outputs/{id}":{"get":{"operationId":"OutputsController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"OutputsController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"OutputsController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}/status":{"get":{"operationId":"PipelinesController_getPipelineStatus","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}/{details}":{"get":{"operationId":"PipelinesController_getPipelineLogs","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines":{"post":{"operationId":"PipelinesController_create","parameters":[],"responses":{"201":{"description":""}}},"get":{"operationId":"PipelinesController_findAll","parameters":[],"responses":{"200":{"description":""}}}},"/pipelines/{id}":{"get":{"operationId":"PipelinesController_findOne","parameters":[],"responses":{"200":{"description":""}}},"put":{"operationId":"PipelinesController_update","parameters":[],"responses":{"200":{"description":""}}},"delete":{"operationId":"PipelinesController_delete","parameters":[],"responses":{"200":{"description":""}}}},"/auth":{"post":{"operationId":"AuthController_signIn","parameters":[],"responses":{"201":{"description":""}}}},"/health":{"get":{"operationId":"HealthController_check","parameters":[],"responses":{"200":{"description":""}}}}},"info":{"title":"Maestro Grpc Documentation","description":"Documentation for Maestro gateway","version":"1.0","contact":{}},"tags":[],"servers":[],"components":{"securitySchemes":{"bearer":{"scheme":"bearer","bearerFormat":"JWT","type":"http"}},"schemas":{}}}