@seidor-cloud-produtos/orbit-backend-lib 2.0.110 → 2.0.111

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

@@ -1,105 +1,482 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('amqplib', () => ({
+    default: {
+        connect: vitest_1.vi.fn(),
+    },
+}));
+const amqplib_1 = tslib_1.__importDefault(require("amqplib"));
+const infra_error_1 = tslib_1.__importDefault(require("../../errors/infra-error"));
 const amqp_lib_1 = tslib_1.__importDefault(require("./amqp-lib"));
-describe('AmqpQueue', () => {
-    it('should not publish if empty memory', async () => {
-        const mq = new amqp_lib_1.default();
-        mq['messagesInMemory'] = [];
-        const mockPublish = (mq['publish'] = vi.fn());
-        await mq['publishMessagesOfMemory']();
-        expect(mockPublish.mock.calls.length).toBe(0);
-    });
-    it('should publish if has messages with correct params', async () => {
-        const mq = new amqp_lib_1.default();
-        mq['messagesInMemory'] = [
-            {
-                exchangeName: 'exchangeName_1',
-                domainEvent: 'domainEvent_1',
-                configs: 'my_cfg_1',
-            },
+const FOURTEEN_DAYS_IN_MS = 14 * 24 * 60 * 60 * 1000;
+const SEVEN_DAYS_IN_MS = 7 * 24 * 60 * 60 * 1000;
+const createChannel = () => ({
+    ack: vitest_1.vi.fn(),
+    assertExchange: vitest_1.vi.fn().mockResolvedValue(undefined),
+    assertQueue: vitest_1.vi.fn().mockResolvedValue(undefined),
+    bindQueue: vitest_1.vi.fn().mockResolvedValue(undefined),
+    close: vitest_1.vi.fn().mockResolvedValue(undefined),
+    consume: vitest_1.vi.fn().mockResolvedValue(undefined),
+    get: vitest_1.vi.fn().mockResolvedValue(null),
+    nack: vitest_1.vi.fn(),
+    prefetch: vitest_1.vi.fn().mockResolvedValue(undefined),
+    publish: vitest_1.vi.fn(),
+    reject: vitest_1.vi.fn(),
+});
+const createConnection = (channel = createChannel()) => ({
+    close: vitest_1.vi.fn().mockResolvedValue(undefined),
+    createChannel: vitest_1.vi.fn().mockResolvedValue(channel),
+    on: vitest_1.vi.fn(),
+    removeAllListeners: vitest_1.vi.fn(),
+});
+const createLogger = () => ({
+    debug: vitest_1.vi.fn(),
+    error: vitest_1.vi.fn(),
+    info: vitest_1.vi.fn(),
+    warn: vitest_1.vi.fn(),
+});
+(0, vitest_1.describe)('AmqpQueue', () => {
+    const connectMock = vitest_1.vi.mocked(amqplib_1.default.connect);
+    const originalNodeEnv = process.env.NODE_ENV;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        amqp_lib_1.default.instance = undefined;
+        process.env.NODE_ENV = 'test';
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        process.env.NODE_ENV = originalNodeEnv;
+    });
+    (0, vitest_1.it)('should reconnect listeners and log on successful connect', async () => {
+        const logger = createLogger();
+        const connection = createConnection();
+        const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+        const reconnectSpy = vitest_1.vi
+            .spyOn(queue, 'treatReconnection')
+            .mockResolvedValue(undefined);
+        connectMock.mockResolvedValue(connection);
+        process.env.NODE_ENV = 'development';
+        await (0, vitest_1.expect)(queue.connect('jobs')).resolves.toBe(queue);
+        (0, vitest_1.expect)(connectMock).toHaveBeenCalledWith('amqp://broker/jobs', {
+            maxStoredMessagesOnError: 500,
+        });
+        (0, vitest_1.expect)(connection.on).toHaveBeenCalledWith('error', vitest_1.expect.any(Function));
+        (0, vitest_1.expect)(connection.on).toHaveBeenCalledWith('close', vitest_1.expect.any(Function));
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('⚙️ PROCESS jobs PID: ', process.pid);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('🐝 Queue connected on vHost: jobs');
+        const onError = connection.on.mock.calls.find(([event]) => event === 'error')?.[1];
+        const onClose = connection.on.mock.calls.find(([event]) => event === 'close')?.[1];
+        await onError?.(new Error('fail'));
+        await onClose?.();
+        (0, vitest_1.expect)(reconnectSpy).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(reconnectSpy).toHaveBeenNthCalledWith(1, 'jobs');
+        (0, vitest_1.expect)(reconnectSpy).toHaveBeenNthCalledWith(2, 'jobs');
+    });
+    (0, vitest_1.it)('should retry the connection before succeeding', async () => {
+        vitest_1.vi.useFakeTimers();
+        const logger = createLogger();
+        const connection = createConnection();
+        const queue = new amqp_lib_1.default({ retry: { maxCount: 1, intervalMs: 10 } }, 'amqp://broker', logger);
+        connectMock
+            .mockRejectedValueOnce(new Error('fail'))
+            .mockResolvedValueOnce(connection);
+        const promise = queue.connect('jobs');
+        await vitest_1.vi.advanceTimersByTimeAsync(10);
+        await (0, vitest_1.expect)(promise).resolves.toBe(queue);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('Retrying connection in... 10ms');
+        (0, vitest_1.expect)(connectMock).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)('should throw when the retry limit is reached', async () => {
+        const queue = new amqp_lib_1.default({ retry: { maxCount: 1, intervalMs: 10 } }, 'amqp://broker', createLogger());
+        connectMock.mockRejectedValue(new Error('fail'));
+        await (0, vitest_1.expect)(queue.connect('jobs', 1)).rejects.toThrow('fail');
+    });
+    (0, vitest_1.it)('should close connection and remove listeners', async () => {
+        const logger = createLogger();
+        const connection = createConnection();
+        const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+        process.env.NODE_ENV = 'development';
+        queue['connection'] = connection;
+        queue['vHost'] = 'jobs';
+        await queue.close();
+        (0, vitest_1.expect)(connection.removeAllListeners).toHaveBeenCalledWith('close');
+        (0, vitest_1.expect)(connection.close).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('⛔ Queue closed on vHost jobs');
+    });
+    (0, vitest_1.it)('should resubscribe channels and republish buffered messages on reconnection', async () => {
+        const logger = createLogger();
+        const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+        const handler = { handle: vitest_1.vi.fn() };
+        queue['channels'].set('queueName', handler);
+        queue['messagesInMemory'] = [
             {
-                exchangeName: 'exchangeName_2',
-                domainEvent: 'domainEvent_2',
-                configs: 'my_cfg_2',
+                exchangeName: 'exchange',
+                domainEvent: { name: 'domain.event' },
+                configs: { persistent: false },
             },
         ];
-        const mockPublish = (mq['publish'] = vi.fn());
-        await mq['publishMessagesOfMemory']();
-        expect(mockPublish.mock.calls).toEqual([
-            ['exchangeName_1', 'domainEvent_1', 'my_cfg_1'],
-            ['exchangeName_2', 'domainEvent_2', 'my_cfg_2'],
-        ]);
-    });
-    describe('get', () => {
-        it('should return null if no message is found', async () => {
-            const mq = new amqp_lib_1.default();
-            mq['connection'] = {
-                createChannel: vi.fn().mockResolvedValue({
-                    get: vi.fn().mockResolvedValue(null),
-                    close: vi.fn(),
-                }),
+        const connectSpy = vitest_1.vi.spyOn(queue, 'connect').mockResolvedValue(queue);
+        const onSpy = vitest_1.vi.spyOn(queue, 'on').mockResolvedValue(undefined);
+        const publishSpy = vitest_1.vi.spyOn(queue, 'publish').mockResolvedValue(undefined);
+        await queue['treatReconnection']('jobs');
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('⛔ Connection Error!!');
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('🔄 Try connection to the vHost jobs');
+        (0, vitest_1.expect)(connectSpy).toHaveBeenCalledWith('jobs');
+        (0, vitest_1.expect)(onSpy).toHaveBeenCalledWith('queueName', handler);
+        (0, vitest_1.expect)(publishSpy).toHaveBeenCalledWith('exchange', { name: 'domain.event' }, { persistent: false });
+        (0, vitest_1.expect)(queue['messagesInMemory']).toHaveLength(0);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('✅ Publishing memory message to: [domain.event]');
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('✅ Published memory messages!');
+    });
+    (0, vitest_1.it)('should not publish buffered messages when there are none', async () => {
+        const queue = new amqp_lib_1.default();
+        queue['messagesInMemory'] = [];
+        queue['publish'] = vitest_1.vi.fn();
+        await queue['publishMessagesOfMemory']();
+        (0, vitest_1.expect)(queue['publish']).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.describe)('get', () => {
+        (0, vitest_1.it)('should return null if no message is found', async () => {
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default();
+            queue['connection'] = {
+                createChannel: vitest_1.vi.fn().mockResolvedValue(channel),
             };
-            const result = await mq.get('queueName');
-            expect(result).toBeNull();
+            const result = await queue.get('queueName');
+            (0, vitest_1.expect)(result).toBeNull();
+            (0, vitest_1.expect)(channel.close).toHaveBeenCalledTimes(1);
         });
-        it('should return rawMessage and channel if message is found', async () => {
+        (0, vitest_1.it)('should return rawMessage and channel if message is found', async () => {
             const fakeMsg = { content: Buffer.from('msg') };
-            const fakeChannel = {
-                get: vi.fn().mockResolvedValue(fakeMsg),
-                close: vi.fn(),
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default();
+            channel.get.mockResolvedValue(fakeMsg);
+            queue['connection'] = {
+                createChannel: vitest_1.vi.fn().mockResolvedValue(channel),
+            };
+            const result = await queue.get('queueName');
+            (0, vitest_1.expect)(result).toEqual({ rawMessage: fakeMsg, channel });
+            (0, vitest_1.expect)(channel.get).toHaveBeenCalledWith('queueName', undefined);
+        });
+        (0, vitest_1.it)('should handle errors and return null', async () => {
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            queue['connection'] = {
+                createChannel: vitest_1.vi.fn().mockRejectedValue(new Error('fail')),
+            };
+            await (0, vitest_1.expect)(queue.get('queueName')).resolves.toBeNull();
+        });
+    });
+    (0, vitest_1.describe)('ack', () => {
+        (0, vitest_1.it)('should call channel.ack and close', async () => {
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default();
+            await queue.ack(channel, 'msg');
+            (0, vitest_1.expect)(channel.ack).toHaveBeenCalledWith('msg');
+            (0, vitest_1.expect)(channel.close).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.it)('should handle errors gracefully', async () => {
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            channel.ack.mockImplementation(() => {
+                throw new Error('fail');
+            });
+            await (0, vitest_1.expect)(queue.ack(channel, 'msg')).resolves.toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('nack', () => {
+        (0, vitest_1.it)('should call channel.nack and close', async () => {
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default();
+            await queue.nack(channel, 'msg', true);
+            (0, vitest_1.expect)(channel.nack).toHaveBeenCalledWith('msg', false, true);
+            (0, vitest_1.expect)(channel.close).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.it)('should handle errors gracefully', async () => {
+            const channel = createChannel();
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            channel.nack.mockImplementation(() => {
+                throw new Error('fail');
+            });
+            await (0, vitest_1.expect)(queue.nack(channel, 'msg')).resolves.toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('on', () => {
+        (0, vitest_1.it)('should consume messages, ack them and keep the callback registered', async () => {
+            const logger = createLogger();
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+            const message = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+            const handler = {
+                getSimultaneity: vitest_1.vi.fn().mockReturnValue(2),
+                handle: vitest_1.vi.fn().mockResolvedValue(undefined),
             };
-            const mq = new amqp_lib_1.default();
-            mq['connection'] = {
-                createChannel: vi.fn().mockResolvedValue(fakeChannel),
+            channel.consume.mockImplementation(async (_queueName, callback) => {
+                await callback(message);
+            });
+            queue['connection'] = connection;
+            queue['vHost'] = 'jobs';
+            process.env.NODE_ENV = 'development';
+            await queue.on('queueName', handler);
+            (0, vitest_1.expect)(channel.prefetch).toHaveBeenCalledWith(2);
+            (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ id: '1' });
+            (0, vitest_1.expect)(channel.ack).toHaveBeenCalledWith(message);
+            (0, vitest_1.expect)(queue['channels'].get('queueName')).toBe(handler);
+            (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('🍯 Consume on queue: [queueName] on vHost jobs');
+        });
+        (0, vitest_1.it)('should reject messages when the consumer fails outside tests', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            const message = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+            const handler = {
+                getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
+                handle: vitest_1.vi.fn().mockRejectedValue(new Error('fail')),
+            };
+            channel.consume.mockImplementation(async (_queueName, callback) => {
+                await callback(message);
+            });
+            queue['connection'] = connection;
+            process.env.NODE_ENV = 'development';
+            await queue.on('queueName', handler);
+            (0, vitest_1.expect)(channel.reject).toHaveBeenCalledWith(message, false);
+        });
+        (0, vitest_1.it)('should not reject messages when the consumer fails in tests', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            const message = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+            const handler = {
+                getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
+                handle: vitest_1.vi.fn().mockRejectedValue(new Error('fail')),
             };
-            const result = await mq.get('queueName');
-            expect(result).toEqual({ rawMessage: fakeMsg, channel: fakeChannel });
-            expect(fakeChannel.get).toHaveBeenCalledWith('queueName', undefined);
-        });
-        it('should handle errors and return null', async () => {
-            const mq = new amqp_lib_1.default();
-            mq['connection'] = {
-                createChannel: vi.fn().mockRejectedValue(new Error('fail')),
+            channel.consume.mockImplementation(async (_queueName, callback) => {
+                await callback(message);
+            });
+            queue['connection'] = connection;
+            await queue.on('queueName', handler);
+            (0, vitest_1.expect)(channel.reject).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('should log consumption errors', async () => {
+            const logger = createLogger();
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+            queue['connection'] = {
+                createChannel: vitest_1.vi.fn().mockRejectedValue(new Error('fail')),
             };
-            const result = await mq.get('queueName');
-            expect(result).toBeNull();
-        });
-    });
-    describe('ack', () => {
-        it('should call channel.ack and close', async () => {
-            const ack = vi.fn();
-            const close = vi.fn();
-            const channel = { ack, close };
-            const mq = new amqp_lib_1.default();
-            await mq.ack(channel, 'msg');
-            expect(ack).toHaveBeenCalledWith('msg');
-            expect(close).toHaveBeenCalled();
-        });
-        it('should handle errors gracefully', async () => {
-            const ack = vi.fn(() => { throw new Error('fail'); });
-            const close = vi.fn();
-            const channel = { ack, close };
-            const mq = new amqp_lib_1.default();
-            await expect(mq.ack(channel, 'msg')).resolves.toBeUndefined();
-        });
-    });
-    describe('nack', () => {
-        it('should call channel.nack and close', async () => {
-            const nack = vi.fn();
-            const close = vi.fn();
-            const channel = { nack, close };
-            const mq = new amqp_lib_1.default();
-            await mq.nack(channel, 'msg', true);
-            expect(nack).toHaveBeenCalledWith('msg', false, true);
-            expect(close).toHaveBeenCalled();
-        });
-        it('should handle errors gracefully', async () => {
-            const nack = vi.fn(() => { throw new Error('fail'); });
-            const close = vi.fn();
-            const channel = { nack, close };
-            const mq = new amqp_lib_1.default();
-            await expect(mq.nack(channel, 'msg')).resolves.toBeUndefined();
+            await queue.on('queueName', {
+                getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
+                handle: vitest_1.vi.fn(),
+            });
+            (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith({
+                message: '⛔ Error to consume messages: [queueName] on vHost undefined',
+                error: vitest_1.expect.any(Error),
+            });
+        });
+    });
+    (0, vitest_1.describe)('publish', () => {
+        (0, vitest_1.it)('should publish with default expiration when it is invalid', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            const event = { name: 'domain.event', payload: { id: '1' } };
+            queue['connection'] = connection;
+            await queue.publish('exchange', event, {
+                expiration: 'invalid',
+                headers: { source: 'spec' },
+            });
+            (0, vitest_1.expect)(channel.publish).toHaveBeenCalledWith('exchange', 'domain.event', Buffer.from(JSON.stringify(event)), {
+                persistent: true,
+                expiration: FOURTEEN_DAYS_IN_MS,
+                headers: { source: 'spec' },
+            });
+            (0, vitest_1.expect)(channel.close).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.it)('should keep null expiration when it is explicitly valid', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            const event = { name: 'domain.event' };
+            queue['connection'] = connection;
+            await queue.publish('exchange', event, {
+                expiration: null,
+            });
+            (0, vitest_1.expect)(channel.publish.mock.calls[0][3]).toEqual({
+                persistent: true,
+                expiration: null,
+            });
         });
+        (0, vitest_1.it)('should store messages in memory when publish times out', async () => {
+            vitest_1.vi.useFakeTimers();
+            const logger = createLogger();
+            const queue = new amqp_lib_1.default({ timeoutSeconds: 1 }, 'amqp://broker', logger);
+            const event = { name: 'domain.event' };
+            queue['publishToServer'] = vitest_1.vi.fn(() => new Promise(resolve => resolve(undefined)));
+            queue['publishToServer'].mockImplementation(() => new Promise(() => undefined));
+            const publishPromise = queue.publish('exchange', event);
+            await vitest_1.vi.advanceTimersByTimeAsync(1000);
+            await publishPromise;
+            (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith({
+                message: '⛔ Error to publish messages to: domain.event.',
+                error: vitest_1.expect.any(infra_error_1.default),
+            });
+            (0, vitest_1.expect)(queue['messagesInMemory']).toEqual([
+                {
+                    exchangeName: 'exchange',
+                    domainEvent: event,
+                    configs: {
+                        expiration: FOURTEEN_DAYS_IN_MS,
+                    },
+                },
+            ]);
+        });
+        (0, vitest_1.it)('should not store messages when storeMessageOnError is false', async () => {
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            queue['publishToServer'] = vitest_1.vi.fn().mockRejectedValue(new Error('fail'));
+            await queue.publish('exchange', { name: 'domain.event' }, {
+                storeMessageOnError: false,
+            });
+            (0, vitest_1.expect)(queue['messagesInMemory']).toHaveLength(0);
+        });
+        (0, vitest_1.it)('should not exceed the configured in-memory error buffer', async () => {
+            const queue = new amqp_lib_1.default({ maxStoredMessagesOnError: 1 }, 'amqp://broker', createLogger());
+            queue['messagesInMemory'] = [
+                {
+                    exchangeName: 'existing',
+                    domainEvent: { name: 'existing.event' },
+                    configs: {},
+                },
+            ];
+            queue['publishToServer'] = vitest_1.vi.fn().mockRejectedValue(new Error('fail'));
+            await queue.publish('exchange', { name: 'domain.event' });
+            (0, vitest_1.expect)(queue['messagesInMemory']).toHaveLength(1);
+        });
+    });
+    (0, vitest_1.describe)('createConsumers', () => {
+        (0, vitest_1.it)('should create exchanges, queues and bindings', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            queue['connection'] = connection;
+            queue['vHost'] = 'jobs';
+            await queue.createConsumers('queueName', {
+                exchangeName: 'exchange',
+                exchangeType: 'direct',
+                queueType: 'quorum',
+                dlq: {
+                    TTLms: 5000,
+                    exchangeName: 'exchange.dlq',
+                },
+            });
+            (0, vitest_1.expect)(channel.assertExchange).toHaveBeenNthCalledWith(1, 'exchange', 'direct', { durable: true });
+            (0, vitest_1.expect)(channel.assertQueue).toHaveBeenNthCalledWith(1, 'queueName', {
+                arguments: {
+                    'x-dead-letter-exchange': 'exchange.dlq.DLX',
+                    'x-dead-letter-routing-key': 'queueName.DLK',
+                    'x-queue-type': 'quorum',
+                },
+                durable: true,
+                deadLetterExchange: 'exchange.dlq.DLX',
+                deadLetterRoutingKey: 'queueName.DLK',
+            });
+            (0, vitest_1.expect)(channel.bindQueue).toHaveBeenNthCalledWith(1, 'queueName', 'exchange', 'queueName');
+            (0, vitest_1.expect)(channel.assertExchange).toHaveBeenNthCalledWith(2, 'exchange.dlq.DLX', 'direct', { durable: true });
+            (0, vitest_1.expect)(channel.assertQueue).toHaveBeenNthCalledWith(2, 'queueName.DLQ', {
+                durable: true,
+                arguments: {
+                    'x-message-ttl': 5000,
+                    'x-queue-type': 'classic',
+                },
+            });
+            (0, vitest_1.expect)(channel.bindQueue).toHaveBeenNthCalledWith(2, 'queueName.DLQ', 'exchange.dlq.DLX', 'queueName.DLK');
+            (0, vitest_1.expect)(channel.close).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.it)('should log errors when queue creation fails', async () => {
+            const logger = createLogger();
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', logger);
+            queue['connection'] = {
+                createChannel: vitest_1.vi.fn().mockRejectedValue(new Error('fail')),
+            };
+            queue['vHost'] = 'jobs';
+            await queue.createConsumers('queueName', {
+                exchangeName: 'exchange',
+                exchangeType: 'direct',
+            });
+            (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith({
+                message: '⛔ Error to create queue: queueName on vHost jobs',
+                error: vitest_1.expect.any(Error),
+            });
+        });
+        (0, vitest_1.it)('should apply default DLQ exchange, type and omit TTL when it is absent', async () => {
+            const channel = createChannel();
+            const connection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            queue['connection'] = connection;
+            await queue.createConsumers('queueName', {
+                exchangeName: 'exchange',
+                exchangeType: '',
+            });
+            (0, vitest_1.expect)(channel.assertExchange).toHaveBeenNthCalledWith(2, 'exchange.DLX', 'direct', { durable: true });
+            (0, vitest_1.expect)(channel.assertQueue).toHaveBeenNthCalledWith(2, 'queueName.DLQ', {
+                durable: true,
+                arguments: {
+                    'x-queue-type': 'classic',
+                },
+            });
+            (0, vitest_1.expect)(channel.bindQueue).toHaveBeenNthCalledWith(2, 'queueName.DLQ', 'exchange.DLX', 'queueName.DLK');
+        });
+    });
+    (0, vitest_1.it)('should add default TTL when creating queues', async () => {
+        const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+        const createConsumersSpy = vitest_1.vi
+            .spyOn(queue, 'createConsumers')
+            .mockResolvedValue(undefined);
+        await queue.createQueues('queueName', {
+            exchangeName: 'exchange',
+            exchangeType: 'direct',
+        });
+        (0, vitest_1.expect)(createConsumersSpy).toHaveBeenCalledWith('queueName', {
+            exchangeName: 'exchange',
+            exchangeType: 'direct',
+            dlq: {
+                TTLms: SEVEN_DAYS_IN_MS,
+            },
+        });
+    });
+    (0, vitest_1.it)('should preserve provided DLQ TTL when creating queues', async () => {
+        const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+        const createConsumersSpy = vitest_1.vi
+            .spyOn(queue, 'createConsumers')
+            .mockResolvedValue(undefined);
+        await queue.createQueues('queueName', {
+            exchangeName: 'exchange',
+            exchangeType: 'fanout',
+            dlq: {
+                TTLms: 5000,
+                exchangeName: 'exchange.dlx',
+            },
+        });
+        (0, vitest_1.expect)(createConsumersSpy).toHaveBeenCalledWith('queueName', {
+            exchangeName: 'exchange',
+            exchangeType: 'fanout',
+            dlq: {
+                TTLms: 5000,
+                exchangeName: 'exchange.dlx',
+            },
+        });
+    });
+    (0, vitest_1.it)('should reuse the singleton for the same vhost and recreate it for another one', async () => {
+        const sameVhostInstance = new amqp_lib_1.default();
+        sameVhostInstance['vHost'] = 'jobs';
+        amqp_lib_1.default.instance = sameVhostInstance;
+        await (0, vitest_1.expect)(amqp_lib_1.default.getInstance('jobs')).resolves.toBe(sameVhostInstance);
+        const nextInstance = new amqp_lib_1.default();
+        const connectSpy = vitest_1.vi
+            .spyOn(amqp_lib_1.default.prototype, 'connect')
+            .mockResolvedValue(nextInstance);
+        amqp_lib_1.default.instance = sameVhostInstance;
+        await (0, vitest_1.expect)(amqp_lib_1.default.getInstance('other')).resolves.toBe(nextInstance);
+        (0, vitest_1.expect)(connectSpy).toHaveBeenCalledWith('other');
     });
 });

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

@@ -1,4 +1,4 @@
-import amqp from "amqplib";
+import amqp from 'amqplib';
 /**
  * Resultado do polling via `channel.get(...)`.
  *

package/dist/clean-arch/infra/scaledjob/amqp/runner.d.ts

@@ -25,9 +25,6 @@ export declare class RabbitMQScaledJobRunner {
     constructor(amqpQueue: AmqpQueue, queueName: string, handler: Handler, options?: IRunnerOptions, logger?: Logger);
     /**
      * Normaliza opções com defaults seguros.
-     *
-     * @remarks Atualmente `manualAck` é normalizado com `|| true`, então
-     * o valor `false` pode ser convertido para `true`.
      */
     private setOptions;
     /**

package/dist/clean-arch/infra/scaledjob/amqp/runner.js

@@ -27,14 +27,11 @@ class RabbitMQScaledJobRunner {
     }
     /**
      * Normaliza opções com defaults seguros.
-     *
-     * @remarks Atualmente `manualAck` é normalizado com `|| true`, então
-     * o valor `false` pode ser convertido para `true`.
      */
     setOptions(options) {
         this.options = {
             errorStrategy: options?.errorStrategy || 'nack-dlq',
-            manualAck: options?.manualAck || true,
+            manualAck: options?.manualAck ?? true,
         };
     }
     /**
@@ -85,9 +82,11 @@ class RabbitMQScaledJobRunner {
     async run() {
         let getResult = null;
         let consumedMessages = 0;
-        const timeoutPerMessageSeconds = this.handler.getTimeoutPerMessageSeconds();
-        const messagesToGet = this.handler.getSimultaneity();
+        let timeoutPerMessageSeconds = undefined;
+        let messagesToGet = 1;
         try {
+            timeoutPerMessageSeconds = this.handler.getTimeoutPerMessageSeconds();
+            messagesToGet = this.handler.getSimultaneity();
             while (consumedMessages < messagesToGet) {
                 try {
                     getResult = await this.amqpQueue.get(this.queueName, {