Merge pull request #189 from AlvaroDavi5/develop

Develop

Author: AlvaroDavi5

src/dev/localstack/queues/SqsClient.ts

@@ -9,13 +9,20 @@ import { ConfigsInterface } from '@core/configs/envs.config';
 import { LoggerInterface } from '@core/logging/logger';
 
 
+type ISendParams = {
+	queueUrl: string;
+	title: string;
+	author: string;
+	message: unknown;
+	messageGroupId: string;
+	messageDeduplicationId: string;
+};
+
 export default class SqsClient {
-	private readonly messageGroupId: string;
 	private readonly sqsClient: SQSClient;
 
 	constructor(
 		private readonly configService: ConfigService,
-		private readonly cryptographyService: { generateUuid: () => string },
 		private readonly logger: LoggerInterface,
 		private readonly dataParserHelper: { toString: (data: unknown) => string },
 	) {
@@ -24,8 +31,6 @@ export default class SqsClient {
 		} } = this.configService.get<ConfigsInterface['integration']['aws']>('integration.aws')!;
 		const showExternalLogs = this.configService.get<ConfigsInterface['application']['showExternalLogs']>('application.showExternalLogs')!;
 
-		this.messageGroupId = 'DefaultGroup';
-
 		this.sqsClient = new SQSClient({
 			endpoint, region, apiVersion, maxAttempts,
 			credentials: { accessKeyId, secretAccessKey, sessionToken },
@@ -39,7 +44,7 @@ export default class SqsClient {
 	}
 
 	private createParams(queueName: string): CreateQueueCommandInput {
-		const isFifoQueue: boolean = queueName?.includes('.fifo');
+		const isFifoQueue = queueName?.endsWith('.fifo');
 
 		const params: CreateQueueCommandInput = {
 			QueueName: queueName,
@@ -54,8 +59,9 @@ export default class SqsClient {
 		return params;
 	}
 
-	private msgParams(queueUrl: string, message: unknown, title: string, author: string): SendMessageCommandInput {
-		const isFifoQueue: boolean = queueUrl?.includes('.fifo');
+	private msgParams(params: ISendParams): SendMessageCommandInput {
+		const { message, title, author, queueUrl, messageGroupId, messageDeduplicationId } = params;
+		const isFifoQueue = queueUrl?.endsWith('.fifo');
 		const messageBody = this.formatMessageBeforeSend(message);
 
 		return {
@@ -71,8 +77,9 @@ export default class SqsClient {
 					StringValue: String(author)
 				},
 			},
-			MessageDeduplicationId: isFifoQueue ? this.cryptographyService.generateUuid() : undefined,
-			MessageGroupId: isFifoQueue ? this.messageGroupId : undefined, // Required for FIFO queues
+			// NOTE - required for FIFO queues
+			MessageDeduplicationId: isFifoQueue ? messageDeduplicationId : undefined,
+			MessageGroupId: isFifoQueue ? messageGroupId : undefined,
 		};
 	}
 
@@ -136,11 +143,9 @@ export default class SqsClient {
 		}
 	}
 
-	public async sendMessage(queueUrl: string, title: string, author: string, message: unknown): Promise<string> {
+	public async sendMessage(params: ISendParams): Promise<string> {
 		try {
-			const result = await this.sqsClient.send(new SendMessageCommand(
-				this.msgParams(queueUrl, message, title, author)
-			));
+			const result = await this.sqsClient.send(new SendMessageCommand(this.msgParams(params)));
 
 			if (!result?.MessageId)
 				throw new Error('Message not sended');

src/dev/localstack/queues/createQueue.ts

@@ -1,10 +1,10 @@
 import { ConfigService } from '@nestjs/config';
-import { configServiceMock, cryptographyServiceMock, dataParserHelperMock, loggerProviderMock } from '@dev/mocks/mockedModules';
+import { configServiceMock, dataParserHelperMock, loggerProviderMock } from '@dev/mocks/mockedModules';
 import SqsClient from './SqsClient';
 
 
 export default (queueName: string, queueUrl: string): void => {
-	const sqsClient = new SqsClient(configServiceMock as unknown as ConfigService, cryptographyServiceMock, loggerProviderMock, dataParserHelperMock);
+	const sqsClient = new SqsClient(configServiceMock as unknown as ConfigService, loggerProviderMock, dataParserHelperMock);
 
 	try {
 		sqsClient.createQueue(queueName).then((createdQueueUrl) => {

src/dev/localstack/queues/sendMessage.ts

@@ -4,7 +4,7 @@ import SqsClient from './SqsClient';
 
 
 export default (queueName: string, queueUrl: string, payload: unknown, title: string, author: string): void => {
-	const sqsClient = new SqsClient(configServiceMock as unknown as ConfigService, cryptographyServiceMock, loggerProviderMock, dataParserHelperMock);
+	const sqsClient = new SqsClient(configServiceMock as unknown as ConfigService, loggerProviderMock, dataParserHelperMock);
 
 	const message = {
 		id: cryptographyServiceMock.generateUuid(),
@@ -15,12 +15,14 @@ export default (queueName: string, queueUrl: string, payload: unknown, title: st
 		timestamp: new Date('2024-06-10T03:52:50.885Z').toISOString(),
 	};
 
-	sqsClient.sendMessage(
+	sqsClient.sendMessage({
 		queueUrl,
+		message,
 		title,
 		author,
-		message,
-	).then(() => {
+		messageGroupId: 'TEST',
+		messageDeduplicationId: cryptographyServiceMock.generateUuid(),
+	}).then(() => {
 		console.debug(`Sended message to ${queueName}`);
 	});
 };

src/modules/api/interceptors/Response.interceptor.ts

@@ -41,11 +41,11 @@ export default class ResponseInterceptor implements NestInterceptor {
 			.pipe(
 				tap((responseData: unknown): void => {
 					const resData = this.dataParserHelper.toString(responseData);
-					this.logger.http(`RESPONDING - ${timestamp} ms: [${method.toUpperCase()}] '${path}' ${resData}`);
+					this.logger.http(`RESPONDING - ${timestamp} ms: [${method.toUpperCase()}] ${path} ${resData}`);
 				}),
 				catchError((responseError: Error): Observable<void> => {
 					const resErr = this.dataParserHelper.toString(responseError);
-					this.logger.http(`RESPONDING ERROR - ${timestamp} ms: [${method.toUpperCase()}] '${path}' ${resErr}`);
+					this.logger.http(`RESPONDING ERROR - ${timestamp} ms: [${method.toUpperCase()}] ${path} ${resErr}`);
 					throw responseError;
 				})
 			);

src/modules/common/utils/externalErrorParser.util.ts

@@ -3,6 +3,7 @@ import { AxiosError } from 'axios';
 import Exceptions from '@core/errors/Exceptions';
 import { ExceptionsEnum } from '@common/enums/exceptions.enum';
 import { HttpStatusEnum } from '@common/enums/httpStatus.enum';
+import { ErrorInterface } from '@shared/internal/interfaces/errorInterface';
 
 
 function exceptionsMapper(statusCode: number) {
@@ -22,17 +23,39 @@ function exceptionsMapper(statusCode: number) {
 }
 
 export default function externalErrorParser(error: unknown): HttpException {
-
-	const exceptions = new Exceptions();
 	let exceptionName: ExceptionsEnum;
+	const errorStacks: string[] = [];
 
-	if (error instanceof HttpException)
+	if (error instanceof HttpException) {
 		exceptionName = exceptionsMapper(error.getStatus());
-	else if (error instanceof AxiosError)
-		exceptionName = exceptionsMapper(error.status ?? error.response?.status ?? 500);
-	else // instanceof Error
-		exceptionName = exceptionsMapper(500);
+		const res = error.getResponse();
+		if (typeof res === 'object') {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const response = res as Record<string, any>;
+			const responseMessage = !!response.message ? JSON.stringify(response.message) : undefined;
+			const responseMetadata = !!response.metadata
+				? JSON.stringify({ message: response.metadata?.message, detail: response.metadata?.detail })
+				: undefined;
 
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return exceptions[String(exceptionName) as ExceptionsEnum](error as any, true);
+			if (responseMessage)
+				errorStacks.push(responseMessage);
+			if (responseMetadata)
+				errorStacks.push(responseMetadata);
+			error.stack = [...errorStacks, error.stack].join('\n');
+		}
+	} else if (error instanceof AxiosError) {
+		exceptionName = exceptionsMapper(error.status ?? 500);
+		const { response } = error;
+		if (typeof response === 'object') {
+			const responseMessage = !!response.data ? JSON.stringify(response.data) : undefined;
+			if (responseMessage)
+				errorStacks.push(responseMessage);
+			error.stack = [...errorStacks, error.stack].join('\n');
+		}
+	} else { // instanceof Error
+		exceptionName = exceptionsMapper(HttpStatusEnum.INTERNAL_SERVER_ERROR);
+	}
+
+	const exceptions = new Exceptions();
+	return exceptions[String(exceptionName) as ExceptionsEnum](error as ErrorInterface, true);
 }

src/modules/core/infra/integration/aws/Sns.client.ts

@@ -7,22 +7,48 @@ import {
 	CreateTopicCommandInput, SubscribeCommandInput, PublishCommandInput,
 } from '@aws-sdk/client-sns';
 import { ConfigsInterface } from '@core/configs/envs.config';
-import CryptographyService from '@core/security/Cryptography.service';
 import Exceptions from '@core/errors/Exceptions';
 import LoggerService from '@core/logging/Logger.service';
 import DataParserHelper from '@common/utils/helpers/DataParser.helper';
 
 
-export type protocolType = 'email' | 'sms' | 'http' | 'https' | 'sqs' | 'lambda' | 'application'
+interface EmailPublishTargets {
+	protocol: 'email';
+	subject: string;
+}
+interface SmsPublishTargets {
+	protocol: 'sms';
+	phoneNumber: string;
+}
+interface SqsPublishTargets {
+	protocol: 'sqs';
+	targetArn?: string;
+}
+interface LambdaPublishTargets {
+	protocol: 'lambda';
+	targetArn?: string;
+}
+
+export type IPublishTargetsOptions =
+	| EmailPublishTargets
+	| SmsPublishTargets
+	| SqsPublishTargets
+	| LambdaPublishTargets;
+export type protocolType = IPublishTargetsOptions['protocol'];
+
+type IPublishParams = IPublishTargetsOptions & {
+	topicArn: string;
+	message: unknown;
+	messageGroupId: string;
+	messageDeduplicationId: string;
+};
 
 @Injectable()
 export default class SnsClient {
-	private readonly messageGroupId: string;
 	private readonly snsClient: SNSClient;
 
 	constructor(
 		private readonly configService: ConfigService,
-		private readonly cryptographyService: CryptographyService,
 		private readonly exceptions: Exceptions,
 		private readonly logger: LoggerService,
 		private readonly dataParserHelper: DataParserHelper,
@@ -32,8 +58,6 @@ export default class SnsClient {
 		} } = this.configService.get<ConfigsInterface['integration']['aws']>('integration.aws')!;
 		const showExternalLogs = this.configService.get<ConfigsInterface['application']['showExternalLogs']>('application.showExternalLogs')!;
 
-		this.messageGroupId = 'DefaultGroup';
-
 		this.snsClient = new SNSClient({
 			endpoint, region, apiVersion, maxAttempts,
 			credentials: { accessKeyId, secretAccessKey, sessionToken },
@@ -47,7 +71,7 @@ export default class SnsClient {
 	}
 
 	private createParams(topicName: string): CreateTopicCommandInput {
-		const isFifoTopic: boolean = topicName?.includes('.fifo');
+		const isFifoTopic = topicName?.endsWith('.fifo');
 
 		const params: CreateTopicCommandInput = {
 			Name: topicName,
@@ -68,28 +92,36 @@ export default class SnsClient {
 		};
 	}
 
-	private publishParams(topicArn: string, topicName: string,
-		protocol: protocolType, message: string, { subject, phoneNumber }: Record<string, string | undefined>): PublishCommandInput {
-		const isFifoTopic: boolean = topicName?.includes('.fifo');
+	private publishParams(params: IPublishParams): PublishCommandInput {
+		const { message, protocol, topicArn, messageGroupId, messageDeduplicationId } = params;
+		const isFifoTopic = topicArn?.endsWith('.fifo');
 		const messageBody = this.formatMessageBeforeSend(message);
 
 		const publishData: PublishCommandInput = {
-			TopicArn: topicArn,
 			Message: messageBody,
-			MessageDeduplicationId: isFifoTopic ? this.cryptographyService.generateUuid() : undefined,
-			MessageGroupId: isFifoTopic ? this.messageGroupId : undefined, // Required for FIFO topics
+			// NOTE - required for FIFO topics
+			MessageDeduplicationId: isFifoTopic ? messageDeduplicationId : undefined,
+			MessageGroupId: isFifoTopic ? messageGroupId : undefined,
 		};
 
 		switch (protocol) {
+			case 'sms':
+				publishData.PhoneNumber = params.phoneNumber;
+				break;
 			case 'email':
-				publishData.Subject = subject;
+				publishData.TopicArn = topicArn;
+				publishData.Subject = params.subject;
 				break;
-			case 'sms':
-				publishData.PhoneNumber = phoneNumber;
+			case 'lambda':
+			case 'sqs':
+				if (params.targetArn) {
+					publishData.TargetArn = params.targetArn;
+				} else {
+					publishData.TopicArn = topicArn;
+				}
 				break;
-			default: // application | sqs | lambda | http(s)
+			default:
 				publishData.TopicArn = topicArn;
-				publishData.TargetArn = topicArn;
 				break;
 		}
 
@@ -168,12 +200,9 @@ export default class SnsClient {
 		}
 	}
 
-	public async publishMessage(topicArn: string, topicName: string,
-		protocol: protocolType, message: string, destination: Record<string, string | undefined>): Promise<string> {
+	public async publishMessage(params: IPublishParams): Promise<string> {
 		try {
-			const result = await this.snsClient.send(new PublishCommand(
-				this.publishParams(topicArn, topicName, protocol, message, destination)
-			));
+			const result = await this.snsClient.send(new PublishCommand(this.publishParams(params)));
 
 			if (!result?.MessageId)
 				throw this.exceptions.internal({ message: 'Message not published' });