@seidor-cloud-produtos/orbit-backend-lib 2.0.8 → 2.0.10

package/dist/clean-arch/application/cache/cache.js

@@ -4,7 +4,7 @@ exports.Cache = void 0;
 const tslib_1 = require("tslib");
 const logger_in_memory_1 = tslib_1.__importDefault(require("lib/clean-arch/infra/logger/logger-in-memory"));
 const env_1 = require("../../infra/environment/env");
-const logger_1 = require("../logger");
+const types_1 = require("lib/clean-arch/infra/environment/types");
 class Cache {
     client;
     elegibleClients;
@@ -47,7 +47,7 @@ class Cache {
             }
             currentClient?.close();
         }
-        await logger_in_memory_1.default.log(`Changed cache client to ${this.client.constructor.name}`, { level: logger_1.LevelEnum.WARN });
+        await logger_in_memory_1.default.log(`Changed cache client to ${this.client.constructor.name}`, { level: types_1.LOG_LEVEL.warn });
         return this;
     }
     async start(options) {
@@ -159,7 +159,7 @@ class Cache {
     }
     async handleException(e) {
         try {
-            await logger_in_memory_1.default.log(JSON.stringify(e), { level: logger_1.LevelEnum.ERROR });
+            await logger_in_memory_1.default.log(JSON.stringify(e), { level: types_1.LOG_LEVEL.error });
         }
         catch { }
         throw e;

package/dist/clean-arch/application/logger/index.d.ts

@@ -1,3 +1,4 @@
+import { LOG_LEVEL } from '../../infra/environment/types';
 export declare enum ActorEnum {
     SYSTEM = "system",
     USER = "user"
@@ -6,17 +7,11 @@ export declare enum CategoryEnum {
     BUSINESS = "business",
     TECHNICAL = "technical"
 }
-export declare enum LevelEnum {
-    INFO = "info",
-    WARN = "warn",
-    ERROR = "error",
-    DEBUG = "debug"
-}
 export type LogProperties = {
     id?: string;
     actorType: ActorEnum;
     category: CategoryEnum;
-    level: LevelEnum;
+    level: LOG_LEVEL;
     actor: string;
     type: string;
     tenantId?: string;

package/dist/clean-arch/application/logger/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LevelEnum = exports.CategoryEnum = exports.ActorEnum = void 0;
+exports.CategoryEnum = exports.ActorEnum = void 0;
 var ActorEnum;
 (function (ActorEnum) {
     ActorEnum["SYSTEM"] = "system";
@@ -11,13 +11,6 @@ var CategoryEnum;
     CategoryEnum["BUSINESS"] = "business";
     CategoryEnum["TECHNICAL"] = "technical";
 })(CategoryEnum || (exports.CategoryEnum = CategoryEnum = {}));
-var LevelEnum;
-(function (LevelEnum) {
-    LevelEnum["INFO"] = "info";
-    LevelEnum["WARN"] = "warn";
-    LevelEnum["ERROR"] = "error";
-    LevelEnum["DEBUG"] = "debug";
-})(LevelEnum || (exports.LevelEnum = LevelEnum = {}));
 class LoggerGateway {
 }
 exports.default = LoggerGateway;

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/env.d.ts

@@ -1,9 +1,8 @@
 import 'dotenv/config';
-import { ENVIRONMENT_TYPES } from './environment';
-import { LevelEnum } from '../../application/logger';
+import { ENVIRONMENT_TYPES, LOG_LEVEL } from './types';
 export declare const env: {
     NODE_ENV: "test" | "production";
     CURRENT_ENVIRONMENT: ENVIRONMENT_TYPES;
-    LOG_LEVEL: LevelEnum.INFO | LevelEnum.ERROR | LevelEnum.DEBUG;
+    LOG_LEVEL: LOG_LEVEL.debug | LOG_LEVEL.info | LOG_LEVEL.error;
     DEFAULT_CACHE_EXPIRATION: number;
 };

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

@@ -3,22 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.env = void 0;
 require("dotenv/config");
 const zod_1 = require("zod");
-const environment_1 = require("./environment");
-const logger_1 = require("../../application/logger");
+const types_1 = require("./types");
 const envSchema = zod_1.z.object({
     NODE_ENV: zod_1.z.enum(['test', 'production']).default('production'),
     CURRENT_ENVIRONMENT: zod_1.z
         .enum([
-        environment_1.ENVIRONMENT_TYPES.TEST,
-        environment_1.ENVIRONMENT_TYPES.LOCAL,
-        environment_1.ENVIRONMENT_TYPES.DEVELOPMENT,
-        environment_1.ENVIRONMENT_TYPES.HOMOLOGATION,
-        environment_1.ENVIRONMENT_TYPES.PRODUCTION,
+        types_1.ENVIRONMENT_TYPES.TEST,
+        types_1.ENVIRONMENT_TYPES.LOCAL,
+        types_1.ENVIRONMENT_TYPES.DEVELOPMENT,
+        types_1.ENVIRONMENT_TYPES.HOMOLOGATION,
+        types_1.ENVIRONMENT_TYPES.PRODUCTION,
     ])
-        .default(environment_1.ENVIRONMENT_TYPES.LOCAL),
+        .default(types_1.ENVIRONMENT_TYPES.LOCAL),
     LOG_LEVEL: zod_1.z
-        .enum([logger_1.LevelEnum.DEBUG, logger_1.LevelEnum.INFO, logger_1.LevelEnum.ERROR])
-        .default(logger_1.LevelEnum.ERROR),
+        .enum([types_1.LOG_LEVEL.debug, types_1.LOG_LEVEL.info, types_1.LOG_LEVEL.error])
+        .default(types_1.LOG_LEVEL.error),
     DEFAULT_CACHE_EXPIRATION: zod_1.z.number().default(360),
 });
 const _env = envSchema.safeParse(process.env);

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

@@ -5,3 +5,9 @@ export declare enum ENVIRONMENT_TYPES {
     LOCAL = "local",
     TEST = "test"
 }
+export declare enum LOG_LEVEL {
+    debug = "debug",
+    info = "info",
+    warn = "warn",
+    error = "error"
+}

package/dist/clean-arch/infra/environment/{environment.js → types.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVIRONMENT_TYPES = void 0;
+exports.LOG_LEVEL = exports.ENVIRONMENT_TYPES = void 0;
 var ENVIRONMENT_TYPES;
 (function (ENVIRONMENT_TYPES) {
     ENVIRONMENT_TYPES["PRODUCTION"] = "prod";
@@ -9,3 +9,10 @@ var ENVIRONMENT_TYPES;
     ENVIRONMENT_TYPES["LOCAL"] = "local";
     ENVIRONMENT_TYPES["TEST"] = "test";
 })(ENVIRONMENT_TYPES || (exports.ENVIRONMENT_TYPES = ENVIRONMENT_TYPES = {}));
+var LOG_LEVEL;
+(function (LOG_LEVEL) {
+    LOG_LEVEL["debug"] = "debug";
+    LOG_LEVEL["info"] = "info";
+    LOG_LEVEL["warn"] = "warn";
+    LOG_LEVEL["error"] = "error";
+})(LOG_LEVEL || (exports.LOG_LEVEL = LOG_LEVEL = {}));

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

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerInMemory = void 0;
 const tslib_1 = require("tslib");
 const env_1 = require("../../infra/environment/env");
-const logger_1 = tslib_1.__importStar(require("../../application/logger"));
+const logger_1 = tslib_1.__importDefault(require("../../application/logger"));
+const types_1 = require("../environment/types");
 class LoggerInMemory extends logger_1.default {
     async log(payload, props) {
         switch (props?.level) {
-            case logger_1.LevelEnum.ERROR:
+            case types_1.LOG_LEVEL.error:
                 return this.error(payload, props);
-            case logger_1.LevelEnum.WARN:
+            case types_1.LOG_LEVEL.warn:
                 return this.warning(payload, props);
             default:
                 return this.info(payload, props);
@@ -25,7 +26,7 @@ class LoggerInMemory extends logger_1.default {
         console.warn(error, props);
     }
     debug() {
-        if (env_1.env.LOG_LEVEL === logger_1.LevelEnum.DEBUG)
+        if (env_1.env.LOG_LEVEL === types_1.LOG_LEVEL.debug)
             return this;
         return undefined;
     }

package/dist/clean-arch/infra/logger/logger-orbit.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importStar(require("../../application/logger"));
 const logger_in_memory_1 = tslib_1.__importDefault(require("./logger-in-memory"));
 const log_error_1 = tslib_1.__importDefault(require("../../domain/errors/log-error"));
+const types_1 = require("../environment/types");
 class LogEvent {
     input;
     name = 'logservice.log';
@@ -60,7 +61,7 @@ class LoggerOrbit extends logger_1.default {
             type: 'default',
             actorType: logger_1.ActorEnum.SYSTEM,
             category: logger_1.CategoryEnum.TECHNICAL,
-            level: logger_1.LevelEnum.INFO,
+            level: types_1.LOG_LEVEL.info,
             expirationHours: sevenDaysInHours,
         };
     }

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,19 @@
+import Handler from 'lib/clean-arch/application/queue/handler';
+import AmqpQueue from '../queue/rabbitmq/amqp-lib';
+import { AmqpQueueGetResult } from '../queue/rabbitmq/types';
+import { RabbitMQScaledJobOptions } from './types';
+import LoggerGateway from 'lib/clean-arch/application/logger';
+export declare class RabbitMQScaledJobRunner<T = any> {
+    private readonly amqpQueue;
+    private readonly queueName;
+    private readonly vHost;
+    private readonly handler;
+    private readonly options;
+    private readonly logger;
+    constructor(amqpQueue: AmqpQueue, queueName: string, vHost: string, handler: Handler, options: RabbitMQScaledJobOptions, logger: LoggerGateway);
+    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,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQScaledJobRunner = void 0;
+class RabbitMQScaledJobRunner {
+    amqpQueue;
+    queueName;
+    vHost;
+    handler;
+    options;
+    logger;
+    constructor(amqpQueue, queueName, vHost, handler, options, logger) {
+        this.amqpQueue = amqpQueue;
+        this.queueName = queueName;
+        this.vHost = vHost;
+        this.handler = handler;
+        this.options = options;
+        this.logger = logger;
+    }
+    async handleError(error, getResult) {
+        this.logger.log(`[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 {
+            this.logger.log('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
+        }
+    }
+    rejectTimeout() {
+        return new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), this.options.timeoutMs));
+    }
+    async finishProcess() {
+        this.logger.log('[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) {
+                this.logger.log('[RabbitMQScaledJobRunner] Nenhuma mensagem disponível.');
+                return;
+            }
+            const { channel, rawMessage } = getResult;
+            const msg = this.options.parse(rawMessage);
+            this.logger.log(`[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) {
+            this.logger.log(`[RabbitMQScaledJobRunner] Erro: ${err.message}`);
+            if (getResult && this.options.manualAck) {
+                await this.handleError(err, getResult);
+            }
+        }
+        finally {
+            try {
+                await this.amqpQueue.close();
+            }
+            catch {
+                this.logger.log('[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,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const runner_1 = require("./runner");
+const logger_in_memory_1 = require("../logger/logger-in-memory");
+(0, vitest_1.describe)('RabbitMQScaledJobRunner', () => {
+    let amqpQueue;
+    let handler;
+    let options;
+    let logger;
+    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' })),
+        };
+        runner = new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', 'vhost', handler, options, new logger_in_memory_1.LoggerInMemory());
+    });
+    (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/dist/infra/http/api-gateway/mapping-model.spec.js

@@ -58,6 +58,7 @@ describe('MappingModel', () => {
             expect(instance['getBody'].mock.calls.length).toBe(1);
             expect(instance['setHeader'].mock.calls).toStrictEqual([
                 ['authorizations', ['test']],
+                ['fiscalidsfromtenant', '[]'],
                 ['accept-encoding', 'identity'],
             ]);
             expect(instance['deleteParams'].mock.calls.length).toBe(1);
@@ -116,6 +117,7 @@ describe('MappingModel', () => {
                 ['header_name_2', 'header_value_2'],
                 ['accept', 'new_header_accept'],
                 ['authorizations', ['test']],
+                ['fiscalidsfromtenant', '[]'],
                 ['accept-encoding', 'identity'],
             ]);
             expect(instance['setQuery'].mock.calls).toStrictEqual([

package/package.json

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