@seidor-cloud-produtos/orbit-backend-lib 2.0.138 → 2.1.0

package/dist/clean-arch/infra/orbit-http-client/orbit-axios-client/orbit-axios-client.spec.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const httpClient = {
+    get: vitest_1.vi.fn(),
+    post: vitest_1.vi.fn(),
+};
+vitest_1.vi.mock('axios', () => ({
+    default: {
+        create: vitest_1.vi.fn(() => httpClient),
+    },
+}));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const http_error_1 = tslib_1.__importDefault(require("../../../domain/errors/http-error"));
+const orbit_axios_client_1 = require("./orbit-axios-client");
+class TestOrbitAxiosClient extends orbit_axios_client_1.OrbitAxiosClient {
+    getTarget() {
+        return 'target-service';
+    }
+    getBaseUrl() {
+        return 'https://example.com';
+    }
+    async sendPost() {
+        return await this.post({
+            endpoint: '/partners',
+            body: { id: '1' },
+            config: {
+                headers: {
+                    authorization: 'token',
+                },
+            },
+        });
+    }
+    async sendGet() {
+        return await this.get({
+            endpoint: '/partners',
+            config: {
+                headers: {
+                    authorization: 'token',
+                },
+                query: {
+                    page: '1',
+                },
+            },
+        });
+    }
+}
+describe('OrbitAxiosClient', () => {
+    afterEach(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    it('should create the axios instance with the target header', () => {
+        new TestOrbitAxiosClient();
+        expect(axios_1.default.create).toHaveBeenCalledWith({
+            baseURL: 'https://example.com',
+            headers: {
+                target: 'target-service',
+            },
+        });
+    });
+    it('should map successful POST and GET responses', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.post.mockResolvedValue({
+            data: { id: '1' },
+            status: 201,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        httpClient.get.mockResolvedValue({
+            data: [{ id: '1' }],
+            status: 200,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        await expect(client.sendPost()).resolves.toEqual({
+            body: { id: '1' },
+            code: 201,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        await expect(client.sendGet()).resolves.toEqual({
+            body: [{ id: '1' }],
+            code: 200,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        expect(httpClient.post).toHaveBeenCalledWith('/partners', { id: '1' }, {
+            headers: {
+                authorization: 'token',
+            },
+        });
+        expect(httpClient.get).toHaveBeenCalledWith('/partners', {
+            headers: {
+                authorization: 'token',
+            },
+            params: {
+                page: '1',
+            },
+        });
+    });
+    it('should convert axios errors into HttpError', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.post.mockRejectedValue({
+            response: {
+                data: {
+                    message: 'Integration failed',
+                },
+                headers: {
+                    'x-request-id': 'request-id',
+                },
+                status: 502,
+            },
+        });
+        await expect(client.sendPost()).rejects.toBeInstanceOf(http_error_1.default);
+        await expect(client.sendPost()).rejects.toEqual(expect.objectContaining({
+            message: 'Integration failed',
+            code: 502,
+            response: {
+                body: {
+                    message: 'Integration failed',
+                },
+                headers: {
+                    'x-request-id': 'request-id',
+                },
+                code: 502,
+            },
+        }));
+    });
+    it('should use the default HttpError message and code when axios error is incomplete', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.get.mockRejectedValue({});
+        await expect(client.sendGet()).rejects.toBeInstanceOf(http_error_1.default);
+        await expect(client.sendGet()).rejects.toEqual(expect.objectContaining({
+            message: 'Integration error',
+            code: 400,
+        }));
+    });
+});

package/dist/clean-arch/infra/orbit-notification-client/discord-client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/infra/orbit-notification-client/discord-client.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const sendMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+const destroyMock = vitest_1.vi.fn();
+const setAuthorMock = vitest_1.vi.fn().mockReturnThis();
+const setColorMock = vitest_1.vi.fn().mockReturnThis();
+const setTitleMock = vitest_1.vi.fn().mockReturnThis();
+const setDescriptionMock = vitest_1.vi.fn().mockReturnThis();
+vitest_1.vi.mock('discord.js', () => ({
+    EmbedBuilder: vitest_1.vi.fn().mockImplementation(() => ({
+        setAuthor: setAuthorMock,
+        setColor: setColorMock,
+        setTitle: setTitleMock,
+        setDescription: setDescriptionMock,
+    })),
+    WebhookClient: vitest_1.vi.fn().mockImplementation(() => ({
+        send: sendMock,
+        destroy: destroyMock,
+    })),
+}));
+const discord_js_1 = require("discord.js");
+const discord_client_1 = require("./discord-client");
+class TestDiscordClient extends discord_client_1.OrbitDiscordNotificationClient {
+    getId() {
+        return 'discord-id';
+    }
+    getToken() {
+        return 'discord-token';
+    }
+}
+describe('OrbitDiscordNotificationClient', () => {
+    afterEach(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    it('should send error notifications through the webhook client', async () => {
+        const client = new TestDiscordClient();
+        await client.sendErrorNotification('API', 'Failure', 'Stacktrace');
+        expect(discord_js_1.WebhookClient).toHaveBeenCalledWith({
+            id: 'discord-id',
+            token: 'discord-token',
+        });
+        expect(discord_js_1.EmbedBuilder).toHaveBeenCalledTimes(1);
+        expect(setAuthorMock).toHaveBeenCalledWith({ name: 'API' });
+        expect(setTitleMock).toHaveBeenCalledWith('Failure');
+        expect(setDescriptionMock).toHaveBeenCalledWith('```Stacktrace```');
+        expect(sendMock).toHaveBeenCalledWith({
+            embeds: [expect.any(Object)],
+        });
+        expect(destroyMock).toHaveBeenCalledTimes(1);
+    });
+    it('should swallow webhook errors', async () => {
+        const client = new TestDiscordClient();
+        sendMock.mockRejectedValueOnce(new Error('failed'));
+        await expect(client.sendErrorNotification('API', 'Failure', 'Stacktrace')).resolves.toBeUndefined();
+        expect(destroyMock).not.toHaveBeenCalled();
+    });
+});

package/dist/clean-arch/infra/queue/create-consumers.d.ts

@@ -1,11 +1,29 @@
 import QueueConnection from '../../application/queue/queue-connection';
+/**
+ * Descreve uma topologia mínima a ser declarada para um consumidor.
+ */
 export interface IConsumer {
     queueName: string;
     configs: any;
 }
+/**
+ * Helper para declarar várias filas/topologias de uma vez.
+ *
+ * A classe espera que a implementação concreta de `queue` ofereça
+ * o método opcional `createConsumers`.
+ *
+ * @deprecated Use CreateQueues instead.
+ *
+ */
 export default abstract class CreateConsumers {
     readonly queue: QueueConnection;
     protected abstract consumers: IConsumer[];
     constructor(queue: QueueConnection);
+    /**
+     * Itera a lista de consumidores e declara a topologia de cada um.
+     *
+     * Se a implementação da fila não suportar `createConsumers`, o método
+     * simplesmente não faz nada.
+     */
     createConsumers(): Promise<void>;
 }

package/dist/clean-arch/infra/queue/create-consumers.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Helper para declarar várias filas/topologias de uma vez.
+ *
+ * A classe espera que a implementação concreta de `queue` ofereça
+ * o método opcional `createConsumers`.
+ *
+ * @deprecated Use CreateQueues instead.
+ *
+ */
 class CreateConsumers {
     queue;
     constructor(queue) {
         this.queue = queue;
     }
+    /**
+     * Itera a lista de consumidores e declara a topologia de cada um.
+     *
+     * Se a implementação da fila não suportar `createConsumers`, o método
+     * simplesmente não faz nada.
+     */
     async createConsumers() {
         if (!this.queue.createConsumers) {
             return;

package/dist/clean-arch/infra/queue/create-queues.d.ts

@@ -0,0 +1,11 @@
+import QueueConnection from '../../application/queue/queue-connection';
+export interface IQueueProps {
+    name: string;
+    configs: any;
+}
+export default abstract class CreateQueues {
+    readonly queue: QueueConnection;
+    protected queues: IQueueProps[];
+    constructor(queue: QueueConnection, queues: IQueueProps[]);
+    createQueues(): Promise<void>;
+}

package/dist/clean-arch/infra/queue/create-queues.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CreateQueues {
+    queue;
+    queues;
+    constructor(queue, queues) {
+        this.queue = queue;
+        this.queues = queues;
+    }
+    async createQueues() {
+        if (!this.queue.createQueues) {
+            return;
+        }
+        for (const queue of this.queues) {
+            await this.queue.createQueues(queue.name, queue.configs);
+        }
+    }
+}
+exports.default = CreateQueues;

package/dist/clean-arch/infra/queue/in-memory/in-memory-queue.d.ts

@@ -1,11 +1,27 @@
 import Handler from '../../../application/queue/handler';
 import Queue from '../../../application/queue/queue';
 import DomainEvent from '../../../domain/events/domain-event';
+/**
+ * Implementação simples de fila em memória.
+ *
+ * Útil para testes ou cenários locais onde não há broker AMQP.
+ */
 export default class QueueInMemory implements Queue {
     queues: PropsQueue[];
     constructor();
+    /**
+     * Percorre os eventos armazenados e executa o handler para os que
+     * combinam com o `queueName`.
+     */
     on(queueName: string, callback: Handler): Promise<void>;
+    /**
+     * Armazena o evento na lista interna.
+     */
     publish(exchangeName: string, domainEvent: DomainEvent): Promise<void>;
+    /**
+     * Armazena o evento na lista interna e retorna sucesso.
+     */
+    publishWaitForConfirms(exchangeName: string, domainEvent: DomainEvent): Promise<boolean>;
 }
 type PropsQueue = {
     exchangeName: string;

package/dist/clean-arch/infra/queue/in-memory/in-memory-queue.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Implementação simples de fila em memória.
+ *
+ * Útil para testes ou cenários locais onde não há broker AMQP.
+ */
 class QueueInMemory {
     queues;
     constructor() {
         this.queues = [];
     }
+    /**
+     * Percorre os eventos armazenados e executa o handler para os que
+     * combinam com o `queueName`.
+     */
     async on(queueName, callback) {
         for (const queue of this.queues) {
             if (queue.domainEvent.name === queueName) {
@@ -12,8 +21,18 @@ class QueueInMemory {
             }
         }
     }
+    /**
+     * Armazena o evento na lista interna.
+     */
     async publish(exchangeName, domainEvent) {
         this.queues.push({ exchangeName, domainEvent });
     }
+    /**
+     * Armazena o evento na lista interna e retorna sucesso.
+     */
+    async publishWaitForConfirms(exchangeName, domainEvent) {
+        this.queues.push({ exchangeName, domainEvent });
+        return true;
+    }
 }
 exports.default = QueueInMemory;

package/dist/clean-arch/infra/queue/queue-controller.d.ts

@@ -1,12 +1,26 @@
 import Handler from '../../application/queue/handler';
 import QueueConnection from '../../application/queue/queue-connection';
+/**
+ * Um handler assíncrono que será registrado em uma fila.
+ *
+ * O uso de `Promise<Handler>` permite construir handlers de forma lazy
+ * (ex.: via factories que dependem de DI/infra).
+ */
 export interface IEventHandler {
     queueName: string;
     callback: Promise<Handler>;
 }
+/**
+ * Helper para subir vários consumidores de forma organizada.
+ *
+ * A implementação concreta deve preencher `eventHandlers`.
+ */
 export default abstract class QueueController {
     readonly queue: QueueConnection;
     protected abstract eventHandlers: IEventHandler[];
     constructor(queue: QueueConnection);
+    /**
+     * Registra todos os handlers configurados através de `queue.on(...)`.
+     */
     runConsumers(): Promise<void>;
 }

package/dist/clean-arch/infra/queue/queue-controller.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Helper para subir vários consumidores de forma organizada.
+ *
+ * A implementação concreta deve preencher `eventHandlers`.
+ */
 class QueueController {
     queue;
     constructor(queue) {
         this.queue = queue;
     }
+    /**
+     * Registra todos os handlers configurados através de `queue.on(...)`.
+     */
     async runConsumers() {
         for (const handler of this.eventHandlers) {
             this.queue.on(handler.queueName, await handler.callback);

package/dist/clean-arch/infra/queue/queue-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/infra/queue/queue-utils.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('child_process', () => ({
+    fork: vitest_1.vi.fn(),
+}));
+const child_process_1 = require("child_process");
+const handler_1 = tslib_1.__importDefault(require("../../application/queue/handler"));
+const create_consumers_1 = tslib_1.__importDefault(require("./create-consumers"));
+const create_queues_1 = tslib_1.__importDefault(require("./create-queues"));
+const in_memory_queue_1 = tslib_1.__importDefault(require("./in-memory/in-memory-queue"));
+const queue_controller_1 = tslib_1.__importDefault(require("./queue-controller"));
+const worker_1 = tslib_1.__importDefault(require("./worker"));
+class TestHandler extends handler_1.default {
+    handleMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+    constructor(simultaneity = 1, timeoutPerMessageSeconds) {
+        super();
+        this.simultaneity = simultaneity;
+        this.timeoutPerMessageSeconds = timeoutPerMessageSeconds;
+    }
+    async handle(message) {
+        await this.handleMock(message);
+    }
+}
+class TestQueueController extends queue_controller_1.default {
+    eventHandlers = [
+        {
+            queueName: 'queue-1',
+            callback: Promise.resolve(new TestHandler()),
+        },
+        {
+            queueName: 'queue-2',
+            callback: Promise.resolve(new TestHandler()),
+        },
+    ];
+}
+class TestCreateConsumers extends create_consumers_1.default {
+    consumers = [
+        {
+            queueName: 'queue-1',
+            configs: { durable: true },
+        },
+        {
+            queueName: 'queue-2',
+            configs: { durable: false },
+        },
+    ];
+}
+class TestCreateQueues extends create_queues_1.default {
+}
+(0, vitest_1.describe)('Queue helpers', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.useFakeTimers();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should expose simultaneity and timeout from handlers', () => {
+        const handler = new TestHandler(3, 10);
+        (0, vitest_1.expect)(handler.getSimultaneity()).toBe(3);
+        (0, vitest_1.expect)(handler.getTimeoutPerMessageSeconds()).toBe(10);
+    });
+    (0, vitest_1.it)('should publish and consume matching in-memory queue messages', async () => {
+        const queue = new in_memory_queue_1.default();
+        const event = {
+            name: 'queue-1',
+            eventDate: new Date(),
+        };
+        const otherEvent = {
+            name: 'queue-2',
+            eventDate: new Date(),
+        };
+        const handler = new TestHandler();
+        await queue.publish('exchange', event);
+        await queue.publish('exchange', otherEvent);
+        await queue.on('queue-1', handler);
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledWith({
+            exchangeName: 'exchange',
+            domainEvent: event,
+        });
+    });
+    (0, vitest_1.it)('should register all queue consumers', async () => {
+        const queue = {
+            on: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestQueueController(queue);
+        await controller.runConsumers();
+        (0, vitest_1.expect)(queue.on).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.on).toHaveBeenNthCalledWith(1, 'queue-1', vitest_1.expect.any(TestHandler));
+        (0, vitest_1.expect)(queue.on).toHaveBeenNthCalledWith(2, 'queue-2', vitest_1.expect.any(TestHandler));
+    });
+    (0, vitest_1.it)('should create consumer topology when supported', async () => {
+        const queue = {
+            createConsumers: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestCreateConsumers(queue);
+        await controller.createConsumers();
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenNthCalledWith(1, 'queue-1', {
+            durable: true,
+        });
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenNthCalledWith(2, 'queue-2', {
+            durable: false,
+        });
+    });
+    (0, vitest_1.it)('should skip consumer topology when not supported', async () => {
+        const queue = {};
+        const controller = new TestCreateConsumers(queue);
+        await (0, vitest_1.expect)(controller.createConsumers()).resolves.toBeUndefined();
+    });
+    (0, vitest_1.it)('should create queues when supported', async () => {
+        const queue = {
+            createQueues: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestCreateQueues(queue, [
+            { name: 'queue-1', configs: { durable: true } },
+            { name: 'queue-2', configs: { durable: false } },
+        ]);
+        await controller.createQueues();
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenNthCalledWith(1, 'queue-1', {
+            durable: true,
+        });
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenNthCalledWith(2, 'queue-2', {
+            durable: false,
+        });
+    });
+    (0, vitest_1.it)('should skip queue creation when not supported', async () => {
+        const queue = {};
+        const controller = new TestCreateQueues(queue, [
+            { name: 'queue-1', configs: { durable: true } },
+        ]);
+        await (0, vitest_1.expect)(controller.createQueues()).resolves.toBeUndefined();
+    });
+    (0, vitest_1.it)('should restart forked workers until the retry limit', async () => {
+        const on = vitest_1.vi.fn();
+        const child = {
+            on,
+            pid: 321,
+        };
+        const consoleLog = vitest_1.vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        const consoleError = vitest_1.vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        vitest_1.vi.mocked(child_process_1.fork).mockReturnValue(child);
+        const worker = new worker_1.default('/tmp/worker.js');
+        worker.fWorker();
+        (0, vitest_1.expect)(child_process_1.fork).toHaveBeenCalledWith('/tmp/worker.js');
+        const onError = on.mock.calls.find(([event]) => event === 'error')?.[1];
+        const onExit = on.mock.calls.find(([event]) => event === 'exit')?.[1];
+        onError?.(new Error('boom'));
+        (0, vitest_1.expect)(consoleError).toHaveBeenCalledWith('⛔ Child process 321 error :', vitest_1.expect.any(Error));
+        onExit?.(1);
+        await vitest_1.vi.runOnlyPendingTimersAsync();
+        (0, vitest_1.expect)(child_process_1.fork).toHaveBeenCalledTimes(2);
+        for (let attempt = 2; attempt <= 6; attempt++) {
+            const currentChild = vitest_1.vi.mocked(child_process_1.fork).mock.results[attempt - 2]?.value || child;
+            const exitHandler = currentChild.on.mock.calls.find(([event]) => event === 'exit')?.[1];
+            exitHandler?.(1);
+            await vitest_1.vi.runOnlyPendingTimersAsync();
+        }
+        (0, vitest_1.expect)(consoleLog).toHaveBeenCalledWith('🔄 Restarting worker process... Attempt 1 of 5');
+        (0, vitest_1.expect)(consoleError).toHaveBeenCalledWith('⛔ Max restart attempts reached. Not restarting worker process 321. Container restart required!');
+    });
+});

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.d.ts

@@ -134,6 +134,10 @@ type CreateConsumers = {
     exchangeName: string;
     exchangeType: 'direct' | 'fanout';
     queueType?: 'classic' | 'quorum' | 'stream';
-    dlqTTLms?: number | null;
+    TTLms?: number | null;
+    dlq?: {
+        TTLms?: number | null;
+        exchangeName?: string;
+    };
 };
 export {};

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.js

@@ -281,29 +281,34 @@ class AmqpQueue {
             await channel.assertExchange(configs.exchangeName, configs.exchangeType, {
                 durable: true,
             });
-            await channel.assertQueue(queueName, {
+            const buildedConfigs = {
                 arguments: {
-                    'x-dead-letter-exchange': `${configs.exchangeName}.DLX`,
+                    'x-dead-letter-exchange': `${configs.dlq?.exchangeName || configs.exchangeName}.DLX`,
                     'x-dead-letter-routing-key': `${queueName || ''}.DLK`,
                     'x-queue-type': configs.queueType || 'classic',
                 },
                 durable: true,
-                deadLetterExchange: `${configs.exchangeName}.DLX`,
+                deadLetterExchange: `${configs.dlq?.exchangeName || configs.exchangeName}.DLX`,
                 deadLetterRoutingKey: `${queueName || ''}.DLK`,
-            });
+            };
+            if (configs.TTLms) {
+                buildedConfigs.arguments['x-message-ttl'] = configs.TTLms;
+            }
+            await channel.assertQueue(queueName, buildedConfigs);
             await channel.bindQueue(queueName, configs.exchangeName, queueName || '');
-            await channel.assertExchange(`${configs.exchangeName}.DLX`, configs.exchangeType || 'direct', {
+            await channel.assertExchange(`${configs.dlq?.exchangeName || configs.exchangeName}.DLX`, configs.exchangeType || 'direct', {
                 durable: true,
             });
-            const oneDayMs = 86400000;
             await channel.assertQueue(`${queueName}.DLQ`, {
                 durable: true,
                 arguments: {
-                    ...(configs.dlqTTLms ? { 'x-message-ttl': configs.dlqTTLms } : {}),
-                    'x-queue-type': configs.queueType || 'classic',
+                    ...(configs.dlq?.TTLms
+                        ? { 'x-message-ttl': configs.dlq?.TTLms }
+                        : {}),
+                    'x-queue-type': 'classic',
                 },
             });
-            await channel.bindQueue(`${queueName}.DLQ`, `${configs.exchangeName}.DLX`, `${queueName || ''}.DLK`);
+            await channel.bindQueue(`${queueName}.DLQ`, `${configs.dlq?.exchangeName || configs.exchangeName}.DLX`, `${queueName || ''}.DLK`);
             await channel.close();
         }
         catch (err) {
@@ -314,12 +319,18 @@ class AmqpQueue {
         }
     }
     async createQueues(queueName, configs) {
+        const oneWeekInMS = 604800000;
         const buildedConfigs = {
             ...configs,
         };
-        if (buildedConfigs.dlqTTLms === undefined) {
-            const sevenDaysInMs = 604800000;
-            buildedConfigs.dlqTTLms = sevenDaysInMs;
+        if (buildedConfigs.TTLms === undefined) {
+            buildedConfigs.TTLms = oneWeekInMS * 2; // 14 days as default TTL for main queue when DLQ is configured, otherwise uses the provided TTL or 14 days if not provided
+        }
+        if (buildedConfigs.dlq?.TTLms === undefined) {
+            buildedConfigs.dlq = {
+                ...(buildedConfigs.dlq || {}),
+                TTLms: oneWeekInMS,
+            };
         }
         return await this.createConsumers(queueName, buildedConfigs);
     }