Files
maestro/src/modules/pipelinesV2/pipelines.service.ts
T

173 lines
4.9 KiB
TypeScript

import {
BadRequestException,
Inject,
InternalServerErrorException,
OnModuleInit,
} from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import {
Messages,
WriteService,
ReadService,
ProtoServices,
} from '@dadosfera/protospack-v2/dist/lib/PipelineV2';
import { lastValueFrom } from 'rxjs';
import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
import { PipelinesClientConfiguration } from './pipelines-client';
import { ICreatePipelineV2Req } from './interfaces';
import { PipelineV2CreateRequest } from '@dadosfera/protospack-v2/dist/lib/PipelineV2/interfaces/messages';
export class PipelinesService implements OnModuleInit {
logger: DadosferaLogger;
pipelineWriteService: WriteService.PipelineV2WriteService;
pipelineReadService: ReadService.PipelineV2ReadService;
constructor(
@Inject(DadosferaLogger)
dadosferaLogger: DadosferaLogger,
@Inject(PipelinesClientConfiguration.name)
private readonly grpcClient: ClientGrpc,
) {
this.logger = dadosferaLogger.logger;
}
onModuleInit() {
this.pipelineReadService =
this.grpcClient.getService<ReadService.PipelineV2ReadService>(
ProtoServices.PipelineV2ReadService,
);
this.pipelineWriteService =
this.grpcClient.getService<WriteService.PipelineV2WriteService>(
ProtoServices.PipelineV2WriteService,
);
}
adjustInputPayload(payload) {
const { input } = payload;
if (input) {
if (input.input_generic) {
const { credentials } = input.input_generic;
return {
...input.input_generic,
credentials: credentials && JSON.parse(credentials),
};
}
if (input.input_s3) return input.input_s3;
if (input.input_jdbc) return input.input_jdbc;
const { credentials } = input;
return {
...input,
credentials: credentials && JSON.parse(credentials),
};
}
return input;
}
async create(
body: ICreatePipelineV2Req,
metadata,
): Promise<Messages.PipelineV2CreateResponse> {
this.logger.info('PipelinesV2ClientService - Create');
const pipelineV2CreateRequest: PipelineV2CreateRequest = {
...body,
input_id: body.input_id,
transformations_ids: body.transformations_ids,
tags: body.tags,
properties: body.properties && JSON.stringify(body.properties),
};
const createPipelineResponse = await lastValueFrom(
this.pipelineWriteService.PipelineV2Create(
pipelineV2CreateRequest,
metadata,
),
).catch((error: { details: string }) => {
if (error.details.includes('INVALID_REQUEST')) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const [errorType, message] = error.details.split('|');
throw new BadRequestException(message);
}
throw new InternalServerErrorException(error.details);
});
this.logger.info('Done');
return createPipelineResponse;
}
async findAll(
data: Messages.PipelineV2FindAllRequest,
metadata,
): Promise<Messages.PipelineV2FindAllResponse> {
this.logger.info('PipelinesClientService - FindAll');
const findAllPipelineResponse = await lastValueFrom(
this.pipelineReadService.PipelineV2FindAll(data, metadata),
)
.then((res) => {
this.logger.info('Done');
return res;
})
.catch((err) => {
this.logger.error(err.message);
throw new Error(err);
});
return findAllPipelineResponse;
}
async findOne(
data: Messages.PipelineV2FindOneRequest,
metadata,
): Promise<Messages.PipelineV2FindOneResponse> {
this.logger.info('PipelinesClientService - FindOne');
const findOnePipelineResponse = await lastValueFrom(
this.pipelineReadService.PipelineV2FindOne(data, metadata),
).catch((err) => {
this.logger.error(err.message);
throw new Error(err);
});
this.logger.info('Done');
return findOnePipelineResponse;
}
async update(UpdatePipelineRequest: Messages.PipelineV2UpdateRequest) {
this.logger.info('PipelinesClientService - Update');
const updatePipelineResponse = await lastValueFrom(
this.pipelineWriteService.PipelineV2Update(UpdatePipelineRequest),
)
.then((res) => {
this.logger.info('Done');
return res;
})
.catch((err) => {
this.logger.error(err.message);
throw new Error(err);
});
return updatePipelineResponse;
}
async remove(data: Messages.PipelineV2RemoveRequest) {
this.logger.info('PipelinesClientService - Remove');
const removePipelineResponse = await lastValueFrom(
this.pipelineWriteService.PipelineV2Remove(data),
)
.then((res) => {
this.logger.info('Done');
return res;
})
.catch((err) => {
this.logger.error(err.message);
throw new Error(err);
});
return removePipelineResponse;
}
}