maestro connection with microservices - clients and modules

This commit is contained in:
rodrigo.zamboni
2022-03-18 10:16:27 -03:00
parent e15a680b9f
commit 1523c6b4d1
25 changed files with 1668 additions and 639 deletions
+22 -16
View File
@@ -1,17 +1,23 @@
// import { join } from 'path';
// import { ClientOptions, Transport } from '@nestjs/microservices';
import { credentials } from '@grpc/grpc-js';
import { ClientOptions, Transport } from '@nestjs/microservices';
// export const InputsClientConfiguration: ClientOptions = {
// transport: Transport.GRPC,
// options: {
// //url: `${process.env.USERS_SVC_URL}:${process.env.USERS_SVC_PORT}`,
// url: `127.0.0.1:50052`,
// package: 'input',
// protoPath: join(__dirname, '..', 'proto', 'input.proto'),
// loader: {
// enums: String,
// objects: true,
// arrays: true,
// },
// },
// };
import { InputProtofile } from '@victorradael/protospack';
export class InputsClientConfiguration {
config(): ClientOptions {
return {
transport: Transport.GRPC,
options: {
url: process.env.INFACTORY_URL,
package: 'input',
// credentials: credentials.createSsl(),
protoPath: InputProtofile,
loader: {
enums: String,
objects: true,
arrays: true,
},
},
};
}
}
+176 -55
View File
@@ -1,64 +1,185 @@
// import {
// Get,
// Post,
// Controller,
// Delete,
// OnModuleInit,
// Put,
// Param,
// } from '@nestjs/common';
// import { Client, ClientGrpc, Payload } from '@nestjs/microservices';
// import { CreateInputGrpcClientDto } from './dto/create-input-grpc-client.dto';
// import { UpdateInputGrpcClientDto } from './dto/update-input-grpc-client.dto';
// import { InputGrpcClientService } from './input-grpc-client.service';
// import { GrpcClientConfiguration } from './client.config';
// import { TestConnectionDTO } from './dto/test-connection-grpc-client.dto';
// import { ApiTags } from '@nestjs/swagger';
import {
OnModuleInit,
Inject,
} from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { InputService } from '@victorradael/protospack';
import { ICreateInputRequest, IIdRequest, ITestConnectionRequest, UpdateInputRequest } from './interfaces';
// @Controller('grpc/input')
// export class InputsClientService implements OnModuleInit {
// @Client(GrpcClientConfiguration)
// private inputServiceClient: ClientGrpc;
export class InputsClientService implements OnModuleInit {
private inputService: InputService;
constructor(
@Inject('INPUTS_PACKAGE') private readonly grpcClient: ClientGrpc,
) {}
// private inputService: InputGrpcClientService;
onModuleInit() {
this.inputService =
this.grpcClient.getService<InputService>(
'InputService',
);
}
// onModuleInit() {
// this.inputService =
// this.inputServiceClient.getService<InputGrpcClientService>(
// 'InputService',
// );
// }
async create(createInputDto: ICreateInputRequest ) {
console.log('InputClientService', 'Create');
// @Post()
// async create(@Payload() createInputDto: CreateInputGrpcClientDto) {
// return this.inputService.create(createInputDto);
// }
const createInputResponse = await new Promise((resolve, reject) => {
this.inputService.Create(createInputDto).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);
});
// @Get()
// list() {
// return this.inputService.list();
// }
return createInputResponse;
}
// @Get(':id')
// show(@Param() id: string) {
// return this.inputService.show(id);
// }
// @Put(':id')
// update(
// @Payload() updateInputDto: UpdateInputGrpcClientDto,
// @Param() id: string,
// ) {
// return this.inputService.update(id, updateInputDto);
// }
async findOne(data: IIdRequest ) {
console.log('InputClientService', 'FindOne');
// @Delete(':id')
// remove(@Param() id: string) {
// return this.inputService.remove(id);
// }
const { id } = data
// @Get('/test-connection')
// testConnection(@Payload() testConnectionDTO: TestConnectionDTO) {
// return this.inputService.testConnection(testConnectionDTO);
// }
// }
const findOneInputResponse = await new Promise((resolve, reject) => {
this.inputService.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 findOneInputResponse;
}
async findAll(data) {
console.log('InputClientService', 'FindAll');
const findAllInputResponse = await new Promise((resolve, reject) => {
this.inputService.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);
});
return findAllInputResponse;
}
async update(updateInputDTO:UpdateInputRequest) {
console.log('InputClientService', 'Update');
console.log(updateInputDTO)
const updateInputResponse = await new Promise((resolve, reject) => {
this.inputService.Update(updateInputDTO).subscribe({
next(x) {
console.log(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 updateInputResponse;
}
async remove(idRequest:IIdRequest) {
console.log('InputClientService', 'Remove');
const removeInputResponse = await new Promise((resolve, reject) => {
this.inputService.Remove(idRequest).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 removeInputResponse;
}
async testConnection(data:ITestConnectionRequest) {
console.log('InputClientService', 'TestCOnnection');
const testConnectionResponse = await new Promise((resolve, reject) => {
this.inputService.TestConnection(data).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 testConnectionResponse;
}
}
+56
View File
@@ -0,0 +1,56 @@
interface Values {
jdbc_user: string;
jdbc_password: string;
database: string;
endpoint: string;
tables: string[];
port: string;
engine: string;
schema: string;
}
interface Cron {
hours: string[];
hour_interval: boolean;
hour_resourse: boolean;
hour_resourse_value: number;
month_day: string[];
month_day_interval: boolean;
month_day_resourse: boolean;
month_day_resourse_value: number;
month: string[];
month_interval: boolean;
month_resourse: boolean;
month_resourse_value: number;
week_days: string[];
week_days_interval: boolean;
week_days_resourse: boolean;
week_days_resourse_value: number;
}
export interface ICreateInputRequest {
cron: Cron;
name: string;
plugin: string;
values: Values;
operation: string;
}
export interface IIdRequest{
id:string;
}
interface UpdateInputRequest {
id: string;
cron: Cron;
name: string;
plugin: string;
values: Values;
operation: string;
}
export interface ITestConnectionRequest {
plugin: string;
values: Values;
}
+21 -16
View File
@@ -1,17 +1,22 @@
// import { join } from 'path';
// import { ClientOptions, Transport } from '@nestjs/microservices';
import { OutputProtofile } from '@victorradael/protospack';
import { ClientOptions, Transport } from '@nestjs/microservices';
import { credentials } from '@grpc/grpc-js';
// export const OutputsClientConfiguration: ClientOptions = {
// transport: Transport.GRPC,
// options: {
// //url: `${process.env.USERS_SVC_URL}:${process.env.USERS_SVC_PORT}`,
// url: `127.0.0.1:50053`,
// package: 'output',
// protoPath: join(__dirname, '..', 'proto', 'output.proto'),
// loader: {
// enums: String,
// objects: true,
// arrays: true,
// },
// },
// };
export class OutputsClientConfiguration {
config(): ClientOptions {
return {
transport: Transport.GRPC,
options: {
url: process.env.OUTFACTORY_URL,
package: 'output',
// credentials: credentials.createSsl(),
protoPath: OutputProtofile,
loader: {
enums: String,
objects: true,
arrays: true,
},
},
};
}
};
+158 -50
View File
@@ -1,57 +1,165 @@
// import {
// Controller,
// Delete,
// Get,
// OnModuleInit,
// Param,
// Post,
// Put,
// } from '@nestjs/common';
// import {
// Client,
// ClientGrpc,
// MessagePattern,
// Payload,
// } from '@nestjs/microservices';
// import { OutputsService } from './outputs.service';
// import { CreateOutputDto } from './dto/create-output.dto';
// import { UpdateOutputDto } from './dto/update-output.dto';
// import { ApiTags } from '@nestjs/swagger';
// import { GrpcClientConfiguration } from './client.config';
import {
Controller,
Delete,
Get,
Inject,
OnModuleInit,
Param,
Post,
Put,
} from '@nestjs/common';
import {
ClientGrpc,
Payload,
} from '@nestjs/microservices';
import { ApiTags } from '@nestjs/swagger';
import { OutputsServiceInterface } from '@victorradael/protospack';
import { objectCamelToSnake } from 'src/utils/CaseConverter';
import { ICreateOutputRequest, IIdRequest, IOutputUpdateRequest } from './interfaces';
// @Controller('output')
// export class OutputsClientService implements OnModuleInit {
// @Client(GrpcClientConfiguration)
// private outputServiceClient: ClientGrpc;
@Controller('output')
export class OutputsClientService implements OnModuleInit {
private outputService: OutputsServiceInterface;
constructor(
@Inject('OUTPUTS_PACKAGE')private readonly grpcClient: ClientGrpc,
){}
// private outputService: OutputsService;
onModuleInit() {
this.outputService =
this.grpcClient.getService<OutputsServiceInterface>('OutputService');
}
// onModuleInit() {
// this.outputService =
// this.outputServiceClient.getService<OutputsService>('OutputService');
// }
// @Post()
// create(@Payload() createOutputDto: CreateOutputDto) {
// return this.outputService.create(createOutputDto);
// }
async create(@Payload() createOutputDto:ICreateOutputRequest ) {
console.log('OutputClientService', 'Create');
// @Get()
// list() {
// return this.outputService.list();
// }
const createOutputResponse = await new Promise((resolve, reject) => {
this.outputService.create(createOutputDto).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 convertedItem = objectCamelToSnake(createOutputResponse["item"])
createOutputResponse["item"] = convertedItem
// @Get(':id')
// show(@Param() id: string) {
// return this.outputService.show(id);
// }
return createOutputResponse;
}
// @Put(':id')
// update(@Param() id: string, @Payload() updateOutputDto: UpdateOutputDto) {
// return this.outputService.update(id, updateOutputDto);
// }
async findAll() {
console.log('OutputClientService', 'FindAll');
// @Delete(':id')
// remove(@Param() id: string) {
// return this.outputService.remove(id);
// }
// }
const findAllOutputResponse = await new Promise((resolve, reject) => {
this.outputService.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 convertedOutputs = findAllOutputResponse['outputs'].map((ot)=>{
return objectCamelToSnake(ot)
})
return {outputs:convertedOutputs};
}
async findOne({id}: IIdRequest) {
console.log('OutputClientService', 'FindOne');
const findOneOutputResponse = await new Promise((resolve, reject) => {
this.outputService.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(findOneOutputResponse);
}
async update(updateOutPutDTO: IOutputUpdateRequest) {
console.log('OutputClientService', 'Update');
const updateOutputResponse = await new Promise((resolve, reject) => {
this.outputService.update(updateOutPutDTO).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(updateOutputResponse);
}
async remove({id}:IIdRequest) {
console.log('OutputClientService', 'Remove');
const removeOutputResponse = await new Promise((resolve, reject) => {
this.outputService.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 removeOutputResponse;
}
}
+22
View File
@@ -0,0 +1,22 @@
export interface ICreateOutputRequest {
operation: string;
name: string;
plugin: string;
values: Values;
}
export interface Values {
prefix: string;
}
export interface IIdRequest{
id:string;
}
export interface IOutputUpdateRequest {
id: string;
operation: string;
values: Values;
plugin: string;
name: string;
}
+21 -16
View File
@@ -1,17 +1,22 @@
// import { join } from 'path';
// import { ClientOptions, Transport } from '@nestjs/microservices';
import { ClientOptions, Transport } from '@nestjs/microservices';
import { PipelineProtofile } from '@victorradael/protospack';
import { credentials } from '@grpc/grpc-js';
// export const PipelinesClientConfiguration: ClientOptions = {
// transport: Transport.GRPC,
// options: {
// //url: `${process.env.USERS_SVC_URL}:${process.env.USERS_SVC_PORT}`,
// url: `127.0.0.1:50054`,
// package: 'pipeline',
// protoPath: join(__dirname, '..', 'proto', 'pipeline.proto'),
// loader: {
// enums: String,
// objects: true,
// arrays: true,
// },
// },
// };
export class PipelinesClientConfiguration {
config(): ClientOptions {
return {
transport: Transport.GRPC,
options: {
url: process.env.PIFACTORY_URL,
package: 'pipeline',
// credentials: credentials.createSsl(),
protoPath: PipelineProtofile,
loader: {
enums: String,
objects: true,
arrays: true,
},
},
};
}
};
+201 -58
View File
@@ -1,68 +1,211 @@
// import {
// Controller,
// Delete,
// Get,
// OnModuleInit,
// Param,
// Post,
// Put,
// } from '@nestjs/common';
// import {
// Client,
// ClientGrpc,
// MessagePattern,
// Payload,
// } from '@nestjs/microservices';
// import { PipelinesService } from './pipelines.service';
// import { CreatePipelineDto } from './dto/create-pipeline.dto';
// import { UpdatePipelineDto } from './dto/update-pipeline.dto';
// import { GrpcClientConfiguration } from './client.config';
import {
Controller,
Delete,
Get,
Inject,
OnModuleInit,
Param,
Post,
Put,
} from '@nestjs/common';
import {
Client,
ClientGrpc,
MessagePattern,
Payload,
} from '@nestjs/microservices';
import { PipelinesServiceInterface } from '@victorradael/protospack';
import { ICreatePipelineDto, IdRequest, IGetPipelineLogsRequest, IUpdatePipelineRequest } from './interfaces';
// @Controller('pipeline')
// export class PipelinesClientService implements OnModuleInit {
// @Client(GrpcClientConfiguration)
// private pipelineServiceClient: ClientGrpc;
export class PipelinesClientService implements OnModuleInit {
private pipelineService: PipelinesServiceInterface;
constructor(
@Inject('PIPELINES_PACKAGE') private readonly grpcClient: ClientGrpc,
){}
// private pipelineService: PipelinesService;
onModuleInit() {
this.pipelineService =
this.grpcClient.getService<PipelinesServiceInterface>(
'PipelineService',
);
}
// onModuleInit() {
// this.pipelineService =
// this.pipelineServiceClient.getService<PipelinesService>(
// 'PipelineService',
// );
// }
// @Post()
// create(@Payload() createPipelineDto: CreatePipelineDto) {
// return this.pipelineService.create(createPipelineDto);
// }
async create(@Payload() createPipelineDto: ICreatePipelineDto ) {
// @Get()
// list() {
// return this.pipelineService.list();
// }
console.log('PipelinesClientService', 'Create');
// @Get(':id')
// show(@Param() id: string) {
// return this.pipelineService.show(id);
// }
const createPipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.create(createPipelineDto).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);
});
// @Put(':id')
// update(@Param() id: string, @Payload() updatePipelineDto: UpdatePipelineDto) {
// return this.pipelineService.update(id, updatePipelineDto);
// }
return createPipelineResponse;
}
// @Delete()
// remove(@Param() id: string) {
// return this.pipelineService.remove(id);
// }
async findAll() {
console.log('PipelinesClientService', 'FindAll');
// @Post()
// getPipelineLogsMessages(@Param() id: string, @Payload() details: string) {
// return this.pipelineService.getPipelineLogsMessages(id, details);
// }
const findAllPipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.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);
});
// getPipelineStatus(id: string) {
// return this.pipelineService.getPipelineStatus(id);
// }
// }
return findAllPipelineResponse;
}
async findOne({id}: IdRequest) {
console.log('PipelinesClientService', 'FindOne');
const findOnePipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.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 findOnePipelineResponse;
}
async update(UpdatePipelineRequest:IUpdatePipelineRequest) {
console.log('PipelinesClientService', 'Update');
const updatePipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.update(UpdatePipelineRequest).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 updatePipelineResponse;
}
async remove({id}:IdRequest) {
console.log('PipelinesClientService', 'Remove');
const removePipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.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 removePipelineResponse;
}
async getPipelineLogsMessages( data:IGetPipelineLogsRequest) {
console.log('PipelinesClientService', 'GetPipelineLogsMessages');
const logsPipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.getPipelineLogs(data).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 logsPipelineResponse;
}
async getPipelineStatus({id}:IdRequest) {
console.log('PipelinesClientService', 'GetPipelineStatus');
const statusPipelineResponse = await new Promise((resolve, reject) => {
this.pipelineService.getPipelineStatus({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 statusPipelineResponse;
}
}
+28
View File
@@ -0,0 +1,28 @@
export interface ICreatePipelineDto {
input: IdRequest;
transformations: IdRequest[];
output: IdRequest;
tags: string[];
name: string;
description: string;
}
export interface IdRequest {
id: string;
}
export interface IUpdatePipelineRequest {
input: IdRequest;
transformations: IdRequest[];
output: IdRequest;
tags: string[];
name: string;
description: string;
id: string;
}
export interface IGetPipelineLogsRequest {
id: string;
details: string;
}
+21 -16
View File
@@ -1,17 +1,22 @@
// import { join } from 'path';
// import { ClientOptions, Transport } from '@nestjs/microservices';
import { ClientOptions, Transport } from '@nestjs/microservices';
import { TransformationProtofile } from '@victorradael/protospack';
import { credentials } from '@grpc/grpc-js';
// export const TransformationsClientConfiguration: ClientOptions = {
// transport: Transport.GRPC,
// options: {
// //url: `${process.env.USERS_SVC_URL}:${process.env.USERS_SVC_PORT}`,
// url: `127.0.0.1:50054`,
// package: 'transformation',
// protoPath: join(__dirname, '..', 'proto', 'transformation.proto'),
// loader: {
// enums: String,
// objects: true,
// arrays: true,
// },
// },
// };
export class TransformationsClientConfiguration {
config(): ClientOptions {
return {
transport: Transport.GRPC,
options: {
url: process.env.TRFACTORY_URL,
package: 'transformation',
// credentials: credentials.createSsl(),
protoPath: TransformationProtofile,
loader: {
enums: String,
objects: true,
arrays: true,
},
},
};
}
};
+151 -57
View File
@@ -1,65 +1,159 @@
// import {
// Controller,
// Delete,
// Get,
// OnModuleInit,
// Param,
// Post,
// Put,
// } from '@nestjs/common';
// import {
// Client,
// ClientGrpc,
// MessagePattern,
// Payload,
// } from '@nestjs/microservices';
// import { TransformationsService } from './transformations.service';
// import { CreateTransformationDto } from './dto/create-transformation.dto';
// import { UpdateTransformationDto } from './dto/update-transformation.dto';
// import { ApiTags } from '@nestjs/swagger';
// import { GrpcClientConfiguration } from './client.config';
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 { TransformationsServiceInterface } from '@victorradael/protospack';
import { ICreateTransformationElement, ICreateTransformationsRequest, IdRequest, IUpdateTransformationRequest } from './interfaces';
// @Controller('transformation')
// export class TransformationsClientService implements OnModuleInit {
// @Client(GrpcClientConfiguration)
// private transformationServiceClient: ClientGrpc;
@Controller('transformation')
export class TransformationsClientService implements OnModuleInit {
private transformationService: TransformationsServiceInterface;
constructor(
@Inject('TRANSFORMATIONS_PACKAGE') private readonly grpcClient: ClientGrpc,
) {}
// private transformationService: TransformationsService;
onModuleInit() {
this.transformationService =
this.grpcClient.getService<TransformationsServiceInterface>(
'TransformationService',
);
}
// onModuleInit() {
// this.transformationService =
// this.transformationServiceClient.getService<TransformationsService>(
// 'TransformationService',
// );
// }
@Post()
async create(createTransformationsDto: ICreateTransformationsRequest) {
console.log('TransformationClientService', 'Create');
// @Post()
// create(@Payload() createTransformationDto: CreateTransformationDto[]) {
// return createTransformationDto.map((transf) =>
// this.transformationService.create(transf),
// );
// }
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);
});
return createTransformationResponse;
}
// @Get()
// list() {
// return this.transformationService.list();
// }
async findAll() {
console.log('TransformationClientService', 'FindAll');
// @Get(':id')
// show(@Payload() id: string) {
// return this.transformationService.show(id);
// }
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);
});
// @Put(':id')
// update(
// @Param() id: string,
// @Payload() updateTransformationDto: UpdateTransformationDto,
// ) {
// return this.transformationService.update(id, updateTransformationDto);
// }
return findAllTransformationResponse;
}
// @Delete(':id')
// remove(@Param() id: string) {
// return this.transformationService.remove(id);
// }
// }
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 findOneTransformationResponse;
}
async update(updateTransformationDTO: IUpdateTransformationRequest) {
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 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 removeTransformationResponse;
}
}
+31
View File
@@ -0,0 +1,31 @@
export interface ICreateTransformationsRequest {
transformations: ICreateTransformationElement[];
}
interface Param {
base_column?: string;
column_name?: string;
n_digits?: number;
start_index?: number;
randbelow?: number;
const?: string;
}
export interface ICreateTransformationElement {
type: string;
params: Param[];
input_source: string;
table: string;
}
export interface IdRequest{
id:string;
}
export interface IUpdateTransformationRequest {
created_at?: string;
id?: string;
client_id?: string;
params: Param[];
type?: string;
input_source?: string;
table?: string;
}