@seidor-cloud-produtos/orbit-backend-lib 1.101.28 → 1.101.30

package/dist/clean-arch/application/queue/queue.d.ts

@@ -3,4 +3,5 @@ import Handler from './handler';
 export default interface Queue {
     on(queueName: string, callback: Handler): Promise<void>;
     publish(exchangeName: string, domainEvent: DomainEvent, configs?: Record<string, any>): Promise<void>;
+    get?(queueName: string, options?: any): Promise<unknown>;
 }

package/dist/clean-arch/infra/environment/types.d.ts

@@ -6,6 +6,6 @@ export declare enum ENVIRONMENT_TYPES {
     TEST = "test"
 }
 export declare enum LOG_LEVEL {
-    debug = "DEBUG",
-    info = "INFO"
+    debug = "debug",
+    info = "info"
 }

package/dist/clean-arch/infra/environment/types.js

@@ -11,6 +11,6 @@ var ENVIRONMENT_TYPES;
 })(ENVIRONMENT_TYPES || (exports.ENVIRONMENT_TYPES = ENVIRONMENT_TYPES = {}));
 var LOG_LEVEL;
 (function (LOG_LEVEL) {
-    LOG_LEVEL["debug"] = "DEBUG";
-    LOG_LEVEL["info"] = "INFO";
+    LOG_LEVEL["debug"] = "debug";
+    LOG_LEVEL["info"] = "info";
 })(LOG_LEVEL || (exports.LOG_LEVEL = LOG_LEVEL = {}));

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

@@ -1,7 +1,9 @@
+import amqp from 'amqplib';
 import Handler from '../../../application/queue/handler';
 import QueueConnection from '../../../application/queue/queue-connection';
 import DomainEvent from '../../../domain/events/domain-event';
 import QueueController from '../queue-controller';
+import { AmqpQueueGetResult } from './types';
 export default class AmqpQueue implements QueueConnection {
     private uri;
     private static instance;
@@ -10,9 +12,12 @@ export default class AmqpQueue implements QueueConnection {
     private messagesInMemory;
     private controller;
     private channels;
-    constructor();
+    constructor(uri?: string);
     connect(vHost: string): Promise<AmqpQueue>;
     close(): Promise<void>;
+    get(queueName: string, options?: amqp.Options.Get | undefined): Promise<AmqpQueueGetResult | null>;
+    ack(channel: amqp.Channel, msg: any): Promise<void>;
+    nack(channel: amqp.Channel, msg: any, requeue?: boolean): Promise<void>;
     on(queueName: string, callback: Handler): Promise<void>;
     publish(exchangeName: string, domainEvent: DomainEvent, configs?: Record<string, any>): Promise<void>;
     createConsumers(queueName: string, configs: CreateConsumers): Promise<void>;

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

@@ -10,8 +10,8 @@ class AmqpQueue {
     messagesInMemory = [];
     controller;
     channels = new Map();
-    constructor() {
-        this.uri = process.env.BROKER_AMQP;
+    constructor(uri = process.env.BROKER_AMQP) {
+        this.uri = uri;
     }
     async connect(vHost) {
         const urlConnection = `${this.uri}/${vHost}`;
@@ -30,6 +30,39 @@ class AmqpQueue {
             console.log(`⛔ Queue closed on vHost ${this.vHost}`);
         }
     }
+    async get(queueName, options) {
+        try {
+            const channel = await this.connection.createChannel();
+            const rawMessage = await channel.get(queueName, options);
+            if (!rawMessage) {
+                await channel.close();
+                return null;
+            }
+            return { rawMessage, channel };
+        }
+        catch (err) {
+            console.log(`⛔ Erro ao obter mensagem de ${queueName}:`, err);
+            return null;
+        }
+    }
+    async ack(channel, msg) {
+        try {
+            channel.ack(msg);
+            await channel.close();
+        }
+        catch (err) {
+            console.log("⛔ Erro ao dar ack:", err);
+        }
+    }
+    async nack(channel, msg, requeue = false) {
+        try {
+            channel.nack(msg, false, requeue);
+            await channel.close();
+        }
+        catch (err) {
+            console.log("⛔ Erro ao dar nack:", err);
+        }
+    }
     async on(queueName, callback) {
         try {
             const channel = await this.connection.createChannel();

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

@@ -26,10 +26,80 @@ describe('AmqpQueue', () => {
         ];
         const mockPublish = (mq['publish'] = vi.fn());
         await mq['publishMessagesOfMemory']();
-        console.log(mockPublish.mock.calls);
         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 result = await mq.get('queueName');
+            expect(result).toBeNull();
+        });
+        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 mq = new amqp_lib_1.default();
+            mq['connection'] = {
+                createChannel: vi.fn().mockResolvedValue(fakeChannel),
+            };
+            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')),
+            };
+            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();
+        });
+    });
 });

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

@@ -0,0 +1,5 @@
+import amqp from "amqplib";
+export type AmqpQueueGetResult = {
+    rawMessage: any;
+    channel: amqp.Channel;
+};

package/dist/clean-arch/infra/queue/rabbitmq/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,17 @@
+import Handler from '../../../clean-arch/application/queue/handler';
+import AmqpQueue from '../queue/rabbitmq/amqp-lib';
+import { AmqpQueueGetResult } from '../queue/rabbitmq/types';
+import { RabbitMQScaledJobOptions } from './types';
+export declare class RabbitMQScaledJobRunner<T = any> {
+    private readonly amqpQueue;
+    private readonly queueName;
+    private readonly vHost;
+    private readonly handler;
+    private readonly options;
+    constructor(amqpQueue: AmqpQueue, queueName: string, vHost: string, handler: Handler, options: RabbitMQScaledJobOptions);
+    private handleError;
+    protected errorStrategy(getResult: AmqpQueueGetResult): Promise<void>;
+    private rejectTimeout;
+    private finishProcess;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQScaledJobRunner = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("../../application/logger"));
+class RabbitMQScaledJobRunner {
+    amqpQueue;
+    queueName;
+    vHost;
+    handler;
+    options;
+    constructor(amqpQueue, queueName, vHost, handler, options) {
+        this.amqpQueue = amqpQueue;
+        this.queueName = queueName;
+        this.vHost = vHost;
+        this.handler = handler;
+        this.options = options;
+    }
+    async handleError(error, getResult) {
+        logger_1.default.error(`[RabbitMQScaledJobRunner] Erro: ${error.message}`);
+        if (!getResult) {
+            return;
+        }
+        return await this.errorStrategy(getResult);
+    }
+    async errorStrategy(getResult) {
+        const { channel, rawMessage } = getResult;
+        try {
+            if (this.options.errorStrategy === 'nack-requeue') {
+                return await this.amqpQueue.nack(channel, rawMessage, true);
+            }
+            return await this.amqpQueue.nack(channel, rawMessage, false);
+        }
+        catch {
+            logger_1.default?.error('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
+        }
+    }
+    rejectTimeout() {
+        return new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), this.options.timeoutMs));
+    }
+    async finishProcess() {
+        logger_1.default.debug()?.info('[RabbitMQScaledJobRunner] Finished process');
+    }
+    async run() {
+        let getResult = null;
+        try {
+            await this.amqpQueue.connect(this.vHost);
+            getResult = await this.amqpQueue.get(this.queueName, {
+                noAck: !this.options.manualAck,
+            });
+            if (!getResult) {
+                logger_1.default
+                    .debug()
+                    ?.warning('[RabbitMQScaledJobRunner] Nenhuma mensagem disponível.');
+                return;
+            }
+            const { channel, rawMessage } = getResult;
+            const msg = this.options.parse(rawMessage);
+            logger_1.default
+                .debug()
+                ?.info(`[RabbitMQScaledJobRunner] Mensagem recebida ${JSON.stringify(msg, null, 2)}`);
+            await Promise.race([this.handler.handle(msg), this.rejectTimeout()]);
+            if (this.options.manualAck) {
+                await this.amqpQueue.ack(channel, rawMessage);
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`[RabbitMQScaledJobRunner] Erro: ${err.message}`);
+            if (getResult && this.options.manualAck) {
+                await this.handleError(err, getResult);
+            }
+        }
+        finally {
+            try {
+                await this.amqpQueue.close();
+            }
+            catch {
+                logger_1.default.error('[RabbitMQScaledJobRunner] Erro ao fechar conexão');
+                await this.finishProcess();
+            }
+        }
+    }
+}
+exports.RabbitMQScaledJobRunner = RabbitMQScaledJobRunner;

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

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

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const runner_1 = require("./runner");
+(0, vitest_1.describe)('RabbitMQScaledJobRunner', () => {
+    let amqpQueue;
+    let handler;
+    let options;
+    let onFinally;
+    let runner;
+    (0, vitest_1.beforeEach)(() => {
+        amqpQueue = {
+            connect: vitest_1.vi.fn().mockResolvedValue(undefined),
+            get: vitest_1.vi.fn().mockResolvedValue(null),
+            ack: vitest_1.vi.fn().mockResolvedValue(undefined),
+            nack: vitest_1.vi.fn().mockResolvedValue(undefined),
+            close: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        handler = { handle: vitest_1.vi.fn().mockResolvedValue(undefined) };
+        options = {
+            manualAck: true,
+            timeoutMs: 1000,
+            errorStrategy: 'nack-dlq',
+            parse: vitest_1.vi.fn((raw) => ({ ok: true, msg: 'parsed' })),
+        };
+        onFinally = vitest_1.vi.fn();
+        runner = new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', 'vhost', handler, options);
+    });
+    (0, vitest_1.it)('should connect, get, handle, ack and close (happy path)', async () => {
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.connect).toHaveBeenCalledWith('vhost');
+        (0, vitest_1.expect)(amqpQueue.get).toHaveBeenCalledWith('queue', { noAck: false });
+        (0, vitest_1.expect)(options.parse).toHaveBeenCalledWith(rawMessage);
+        (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ ok: true, msg: 'parsed' });
+        (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should not ack if manualAck is false', async () => {
+        options.manualAck = false;
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.ack).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should nack with correct strategy', async () => {
+        options.errorStrategy = 'nack-requeue';
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        handler.handle = vitest_1.vi.fn(() => { throw new Error('fail'); });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, true);
+    });
+    (0, vitest_1.it)('should nack with default strategy', async () => {
+        options.errorStrategy = 'nack-dlq';
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        handler.handle = vitest_1.vi.fn(() => { throw new Error('fail'); });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+    });
+    (0, vitest_1.it)('should log and return if no message is available', async () => {
+        amqpQueue.get.mockResolvedValue(null);
+        await runner.run();
+        (0, vitest_1.expect)(handler.handle).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should log error if amqpQueue.connect throws', async () => {
+        amqpQueue.connect.mockRejectedValue(new Error('fail'));
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.connect).toHaveBeenCalledWith('vhost');
+    });
+    (0, vitest_1.it)('should log error if amqpQueue.close throws', async () => {
+        amqpQueue.close.mockRejectedValue(new Error('fail'));
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should call onFinally if close fails', async () => {
+        amqpQueue.close.mockRejectedValue(new Error('fail'));
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        // onFinally is called inside finishProcess
+        // No assertion needed for logger, just ensure no throw
+    });
+    (0, vitest_1.it)('should handle timeout and call nack', async () => {
+        options.timeoutMs = 10;
+        handler.handle = vitest_1.vi.fn(() => new Promise(() => { }));
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+    });
+    (0, vitest_1.it)('should handle error in nack gracefully', async () => {
+        amqpQueue.nack.mockRejectedValue(new Error('fail'));
+        options.errorStrategy = 'nack-dlq';
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        handler.handle = vitest_1.vi.fn(() => { throw new Error('fail'); });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+    });
+    (0, vitest_1.it)('should handle error in ack gracefully', async () => {
+        amqpQueue.ack.mockRejectedValue(new Error('fail'));
+        const rawMessage = { content: Buffer.from('msg') };
+        const channel = {};
+        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
+    });
+});

package/dist/clean-arch/infra/scaledjob/types.d.ts

@@ -0,0 +1,7 @@
+export type ErrorStrategy = "nack-dlq" | "nack-requeue";
+export type RabbitMQScaledJobOptions = {
+    parse: (raw: any) => any;
+    manualAck: boolean;
+    errorStrategy: ErrorStrategy;
+    timeoutMs: number;
+};

package/dist/clean-arch/infra/scaledjob/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "1.101.28",
+  "version": "1.101.30",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",