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

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

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
-/**
- * Executor simples de worker em processo separado com auto-restart.
- *
- * Útil para subir consumidores/filas em um script dedicado, mantendo
- * o processo principal mais estável.
- */
 class ForkWorker {
     attemptCount = 0;
     maxAttempts = 5;
@@ -15,9 +9,6 @@ class ForkWorker {
     constructor(workerPath) {
         this.workerPath = workerPath;
     }
-    /**
-     * Inicia o worker e aplica a política de reinício em caso de erro/exit.
-     */
     fWorker() {
         const child = (0, child_process_1.fork)(this.workerPath);
         child.on('error', err => {

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

@@ -6,52 +6,19 @@ import { RabbitMQScaledJobOptions } from './types';
 import { Logger } from '../../../application/logger';
 export interface IRunnerOptions extends Partial<RabbitMQScaledJobOptions> {
 }
-/**
- * Runner de ScaledJob para RabbitMQ/AMQP baseado em polling (`get`).
- *
- * Fluxo geral por execução:
- * - Conecta no broker.
- * - Faz polling da fila até atingir o limite configurado.
- * - Processa cada mensagem com o `Handler`.
- * - Faz `ack` em sucesso e `nack` em erro (quando `manualAck` está ativo).
- * - Fecha a conexão ao final.
- */
-export declare class RabbitMQScaledJobRunner {
+export declare class RabbitMQScaledJobRunner<T = any> {
     private readonly amqpQueue;
     private readonly queueName;
     private readonly handler;
     protected logger: Logger;
     private options;
     constructor(amqpQueue: AmqpQueue, queueName: string, handler: Handler, options?: IRunnerOptions, logger?: Logger);
-    /**
-     * Normaliza opções com defaults seguros.
-     */
     private setOptions;
-    /**
-     * Aplica a estratégia de erro quando há uma mensagem em contexto.
-     */
     private handleError;
-    /**
-     * Executa a estratégia de erro escolhida (`nack-dlq` ou `nack-requeue`).
-     */
     protected errorStrategy(getResult: AmqpQueueGetResult): Promise<void>;
-    /**
-     * Desserializa a mensagem AMQP assumindo JSON no `content`.
-     */
     protected parse(raw: {
         content: Buffer;
     }): any;
-    /**
-     * Hook final simples para logs quando o processo termina.
-     */
-    private finishProcess;
-    /**
-     * Executa o ciclo completo do job.
-     *
-     * O número de mensagens por execução segue esta ordem:
-     * - `options.numberOfMessagesToGet` (deprecated).
-     * - `handler.getSimultaneity()`.
-     * - fallback para `1`.
-     */
+    protected finishProcess(): Promise<never>;
     run(): Promise<void>;
 }

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

@@ -2,16 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RabbitMQScaledJobRunner = void 0;
 const timeout_1 = require("../../../shared/timeout");
-/**
- * Runner de ScaledJob para RabbitMQ/AMQP baseado em polling (`get`).
- *
- * Fluxo geral por execução:
- * - Conecta no broker.
- * - Faz polling da fila até atingir o limite configurado.
- * - Processa cada mensagem com o `Handler`.
- * - Faz `ack` em sucesso e `nack` em erro (quando `manualAck` está ativo).
- * - Fecha a conexão ao final.
- */
 class RabbitMQScaledJobRunner {
     amqpQueue;
     queueName;
@@ -25,27 +15,18 @@ class RabbitMQScaledJobRunner {
         this.logger = logger;
         this.setOptions(options);
     }
-    /**
-     * Normaliza opções com defaults seguros.
-     */
     setOptions(options) {
         this.options = {
             errorStrategy: options?.errorStrategy || 'nack-dlq',
-            manualAck: options?.manualAck ?? true,
+            manualAck: options?.manualAck || true,
         };
     }
-    /**
-     * Aplica a estratégia de erro quando há uma mensagem em contexto.
-     */
     async handleError(error, getResult) {
         if (!getResult) {
             return;
         }
         return await this.errorStrategy(getResult);
     }
-    /**
-     * Executa a estratégia de erro escolhida (`nack-dlq` ou `nack-requeue`).
-     */
     async errorStrategy(getResult) {
         const { channel, rawMessage } = getResult;
         try {
@@ -58,35 +39,19 @@ class RabbitMQScaledJobRunner {
             this.logger.info('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
         }
     }
-    /**
-     * Desserializa a mensagem AMQP assumindo JSON no `content`.
-     */
     parse(raw) {
         return JSON.parse(raw.content.toString());
     }
-    /**
-     * Hook final simples para logs quando o processo termina.
-     */
     async finishProcess() {
         this.logger.info('[RabbitMQScaledJobRunner] Finished process');
         return process.exit(0);
     }
-    /**
-     * Executa o ciclo completo do job.
-     *
-     * O número de mensagens por execução segue esta ordem:
-     * - `options.numberOfMessagesToGet` (deprecated).
-     * - `handler.getSimultaneity()`.
-     * - fallback para `1`.
-     */
     async run() {
         let getResult = null;
         let consumedMessages = 0;
-        let timeoutPerMessageSeconds = undefined;
-        let messagesToGet = 1;
+        const timeoutPerMessageSeconds = this.handler.getTimeoutPerMessageSeconds();
+        const messagesToGet = this.handler.getSimultaneity();
         try {
-            timeoutPerMessageSeconds = this.handler.getTimeoutPerMessageSeconds();
-            messagesToGet = this.handler.getSimultaneity();
             while (consumedMessages < messagesToGet) {
                 try {
                     getResult = await this.amqpQueue.get(this.queueName, {

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

@@ -5,113 +5,123 @@ const runner_1 = require("./runner");
 (0, vitest_1.describe)('RabbitMQScaledJobRunner', () => {
     let amqpQueue;
     let handler;
-    let logger;
+    let options;
+    let onFinally;
+    let runner;
     (0, vitest_1.beforeEach)(() => {
         amqpQueue = {
-            get: vitest_1.vi.fn(),
+            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),
-            getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
-            getTimeoutPerMessageSeconds: vitest_1.vi.fn().mockReturnValue(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' })),
         };
-        logger = {
-            info: vitest_1.vi.fn(),
-            warn: vitest_1.vi.fn(),
-            error: vitest_1.vi.fn(),
-            debug: vitest_1.vi.fn(),
-        };
-        vitest_1.vi.spyOn(process, 'exit').mockImplementation((() => undefined));
-    });
-    (0, vitest_1.afterEach)(() => {
-        vitest_1.vi.useRealTimers();
-        vitest_1.vi.restoreAllMocks();
+        onFinally = vitest_1.vi.fn();
+        runner = new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', handler, options);
     });
-    const makeRunner = (options) => new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', handler, options, logger);
-    (0, vitest_1.it)('should connect the polling flow, parse the message, ack and close', async () => {
-        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+    (0, vitest_1.it)('should connect, get, handle, ack and close (happy path)', async () => {
+        const rawMessage = { content: Buffer.from('msg') };
         const channel = {};
-        const runner = makeRunner();
         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)(handler.handle).toHaveBeenCalledWith({ id: '1' });
+        (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).toHaveBeenCalledTimes(1);
-        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should skip ack when manualAck is disabled', async () => {
-        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
-        const runner = makeRunner({ manualAck: false });
-        amqpQueue.get.mockResolvedValue({ channel: {}, rawMessage });
+    (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.get).toHaveBeenCalledWith('queue', { noAck: true });
         (0, vitest_1.expect)(amqpQueue.ack).not.toHaveBeenCalled();
-        (0, vitest_1.expect)(amqpQueue.nack).not.toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should apply nack-requeue when handler fails', async () => {
-        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+    (0, vitest_1.it)('should nack with correct strategy', async () => {
+        options.errorStrategy = 'nack-requeue';
+        const rawMessage = { content: Buffer.from('msg') };
         const channel = {};
-        const runner = makeRunner({ errorStrategy: 'nack-requeue' });
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle.mockRejectedValue(new Error('fail'));
+        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.expect)(amqpQueue.ack).not.toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should stop when there is no message available', async () => {
-        const runner = makeRunner();
+    (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.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Nenhuma mensagem disponível.');
     });
-    (0, vitest_1.it)('should handle timeout and nack the message', async () => {
-        vitest_1.vi.useFakeTimers();
-        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+    (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 = {};
-        const runner = makeRunner();
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle.mockImplementation(() => new Promise(() => undefined));
-        handler.getTimeoutPerMessageSeconds.mockReturnValue(1);
-        const runPromise = runner.run();
-        await vitest_1.vi.advanceTimersByTimeAsync(1000);
-        await runPromise;
-        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
-        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro: Timeout');
-    });
-    (0, vitest_1.it)('should ignore errors when nack strategy fails', async () => {
-        const runner = makeRunner({ errorStrategy: 'nack-dlq' });
-        amqpQueue.nack.mockRejectedValue(new Error('nack failed'));
-        await (0, vitest_1.expect)(runner['errorStrategy']({
-            channel: {},
-            rawMessage: { content: Buffer.from('{}') },
-        })).resolves.toBeUndefined();
-        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
+        await runner.run();
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should return early when there is no message to handle as error context', async () => {
-        const runner = makeRunner();
-        await (0, vitest_1.expect)(runner['handleError'](new Error('fail'), null)).resolves.toBeUndefined();
-        (0, vitest_1.expect)(amqpQueue.nack).not.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 log close errors and still finish the process', async () => {
-        const runner = makeRunner();
-        amqpQueue.get.mockResolvedValue(null);
-        amqpQueue.close.mockRejectedValue(new Error('close failed'));
+    (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)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro ao fechar conexão', vitest_1.expect.any(Error));
-        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
     });
-    (0, vitest_1.it)('should handle unexpected outer errors and still close', async () => {
-        const runner = makeRunner();
-        handler.getSimultaneity.mockImplementation(() => {
-            throw new Error('outer failure');
+    (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)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro: {}');
-        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalledTimes(1);
+        (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/amqp/types.d.ts

@@ -1,25 +1,6 @@
 import { ScaledJobOptions } from '../types';
-/**
- * Estratégia de erro aplicada quando o handler falha.
- */
 export type ErrorStrategy = 'nack-dlq' | 'nack-requeue';
-/**
- * Opções para execução de ScaledJobs com RabbitMQ/AMQP.
- */
 export interface RabbitMQScaledJobOptions extends ScaledJobOptions {
-    /**
-     * @deprecated Use the simultaneity attribute on Handler.
-     */
-    numberOfMessagesToGet?: number;
-    /**
-     * Define se o runner deve confirmar manualmente as mensagens.
-     *
-     * Quando `true`, o runner usa `ack` em caso de sucesso e `nack` em erro.
-     * Quando `false`, o polling é feito com `noAck: true`.
-     */
     manualAck: boolean;
-    /**
-     * Define o que fazer quando ocorre erro no processamento.
-     */
     errorStrategy: ErrorStrategy;
 }

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

@@ -1,15 +1,6 @@
 import Handler from '../../../../clean-arch/application/queue/handler';
 import { SQSScaledJobOptions } from './types';
 import { Logger } from '../../../../clean-arch/application/logger';
-/**
- * Runner de ScaledJob para AWS SQS baseado em polling.
- *
- * Fluxo geral por execução:
- * - Faz polling com `ReceiveMessageCommand`.
- * - Processa a mensagem com o `Handler`.
- * - Em sucesso, deleta com `DeleteMessageCommand`.
- * - Respeita simultaneidade e timeout configurados no `Handler`.
- */
 export declare class SQSScaledJobRunner {
     private readonly handler;
     private readonly queueUrl;
@@ -18,22 +9,8 @@ export declare class SQSScaledJobRunner {
     private sqs;
     private timedOut;
     constructor(handler: Handler, queueUrl: string, options: SQSScaledJobOptions, logger?: Logger);
-    /**
-     * Desserializa a mensagem do SQS.
-     *
-     * O SQS entrega o corpo como string e este método garante que seja JSON.
-     */
     private static parseMessage;
-    /**
-     * Processa mensagens até atingir o limite de simultaneidade ou timeout.
-     */
     process(): Promise<void>;
-    /**
-     * Marca o runner como expirado após um timeout global.
-     */
     private timeout;
-    /**
-     * Executa o job concorrendo com um timeout global (quando configurado).
-     */
     run(): Promise<void>;
 }

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

@@ -3,15 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQSScaledJobRunner = void 0;
 const client_sqs_1 = require("@aws-sdk/client-sqs");
 const timeout_1 = require("../../../../clean-arch/shared/timeout");
-/**
- * Runner de ScaledJob para AWS SQS baseado em polling.
- *
- * Fluxo geral por execução:
- * - Faz polling com `ReceiveMessageCommand`.
- * - Processa a mensagem com o `Handler`.
- * - Em sucesso, deleta com `DeleteMessageCommand`.
- * - Respeita simultaneidade e timeout configurados no `Handler`.
- */
 class SQSScaledJobRunner {
     handler;
     queueUrl;
@@ -26,11 +17,6 @@ class SQSScaledJobRunner {
         this.logger = logger;
         this.sqs = new client_sqs_1.SQSClient({ region: this.options.sqsRegion });
     }
-    /**
-     * Desserializa a mensagem do SQS.
-     *
-     * O SQS entrega o corpo como string e este método garante que seja JSON.
-     */
     static parseMessage(rawMessage) {
         if (rawMessage === null || rawMessage === undefined) {
             throw new Error('[SQSScaledJobRunner] Mensagem inválida.');
@@ -40,9 +26,6 @@ class SQSScaledJobRunner {
         }
         return JSON.parse(rawMessage);
     }
-    /**
-     * Processa mensagens até atingir o limite de simultaneidade ou timeout.
-     */
     async process() {
         let consumedMessages = 0;
         const simultaneity = this.handler.getSimultaneity();
@@ -83,22 +66,15 @@ class SQSScaledJobRunner {
             }
         }
     }
-    /**
-     * Marca o runner como expirado após um timeout global.
-     */
     async timeout(timeoutSeconds) {
         await (0, timeout_1.sleep)(timeoutSeconds * 1000);
         this.timedOut = true;
     }
-    /**
-     * Executa o job concorrendo com um timeout global (quando configurado).
-     */
     async run() {
-        const promises = [this.process()];
         if (this.options.processTimeoutSeconds) {
-            promises.push(this.timeout(this.options.processTimeoutSeconds));
+            this.timeout(this.options.processTimeoutSeconds);
         }
-        await Promise.race(promises);
+        await this.process();
     }
 }
 exports.SQSScaledJobRunner = SQSScaledJobRunner;

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

@@ -1,24 +1,6 @@
 import { ScaledJobOptions } from '../types';
-/**
- * Opções para execução de ScaledJobs com AWS SQS.
- */
 export interface SQSScaledJobOptions extends ScaledJobOptions {
-    /**
-     * Região AWS onde a fila SQS está localizada.
-     *
-     * Ex.: `us-east-1`.
-     */
     sqsRegion: string;
-    /**
-     * Tempo máximo (em segundos) que o job pode executar antes de encerrar.
-     *
-     * Quando definido, o runner disputa o processamento com um timeout global.
-     */
     processTimeoutSeconds?: number;
-    /**
-     * Tempo de long polling (em segundos) usado no ReceiveMessage.
-     *
-     * Valores maiores reduzem custo e aumentam eficiência de consumo.
-     */
     waitMessagesTimeSeconds?: number;
 }

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

@@ -1,7 +1,2 @@
-/**
- * Marcador para opções compartilhadas entre runners de ScaledJob.
- *
- * Hoje está vazio, mas serve como ponto de extensão comum.
- */
 export interface ScaledJobOptions {
 }