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

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

@@ -1,8 +1,17 @@
+/**
+ * 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.
+ */
 export default class ForkWorker {
     private attemptCount;
     private maxAttempts;
     private retryDelay;
     private workerPath;
     constructor(workerPath: string);
+    /**
+     * Inicia o worker e aplica a política de reinício em caso de erro/exit.
+     */
     fWorker(): void;
 }

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

@@ -1,6 +1,12 @@
 "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;
@@ -9,6 +15,9 @@ 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,19 +6,52 @@ import { RabbitMQScaledJobOptions } from './types';
 import { Logger } from '../../../application/logger';
 export interface IRunnerOptions extends Partial<RabbitMQScaledJobOptions> {
 }
-export declare class RabbitMQScaledJobRunner<T = any> {
+/**
+ * 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 {
     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;
-    protected finishProcess(): Promise<never>;
+    /**
+     * 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`.
+     */
     run(): Promise<void>;
 }

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

@@ -2,6 +2,16 @@
 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;
@@ -15,18 +25,27 @@ 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 {
@@ -39,19 +58,35 @@ 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;
-        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, {

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

@@ -5,123 +5,113 @@ const runner_1 = require("./runner");
 (0, vitest_1.describe)('RabbitMQScaledJobRunner', () => {
     let amqpQueue;
     let handler;
-    let options;
-    let onFinally;
-    let runner;
+    let logger;
     (0, vitest_1.beforeEach)(() => {
         amqpQueue = {
-            connect: vitest_1.vi.fn().mockResolvedValue(undefined),
-            get: vitest_1.vi.fn().mockResolvedValue(null),
+            get: vitest_1.vi.fn(),
             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' })),
+        handler = {
+            handle: vitest_1.vi.fn().mockResolvedValue(undefined),
+            getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
+            getTimeoutPerMessageSeconds: vitest_1.vi.fn().mockReturnValue(undefined),
         };
-        onFinally = vitest_1.vi.fn();
-        runner = new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', handler, options);
+        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();
     });
-    (0, vitest_1.it)('should connect, get, handle, ack and close (happy path)', async () => {
-        const rawMessage = { content: Buffer.from('msg') };
+    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' })) };
         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)(options.parse).toHaveBeenCalledWith(rawMessage);
-        (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ ok: true, msg: 'parsed' });
+        (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ id: '1' });
         (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
-        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
     });
-    (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 });
+    (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 });
         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 nack with correct strategy', async () => {
-        options.errorStrategy = 'nack-requeue';
-        const rawMessage = { content: Buffer.from('msg') };
+    (0, vitest_1.it)('should apply nack-requeue when handler fails', async () => {
+        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
         const channel = {};
+        const runner = makeRunner({ errorStrategy: 'nack-requeue' });
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw new Error('fail');
-        });
+        handler.handle.mockRejectedValue(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 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 () => {
+    (0, vitest_1.it)('should stop when there is no message available', async () => {
+        const runner = makeRunner();
         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 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') };
+    (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' })) };
         const channel = {};
+        const runner = makeRunner();
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        await runner.run();
-        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+        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 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 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');
     });
-    (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 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 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');
-        });
+    (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'));
         await runner.run();
-        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+        (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.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 });
+    (0, vitest_1.it)('should handle unexpected outer errors and still close', async () => {
+        const runner = makeRunner();
+        handler.getSimultaneity.mockImplementation(() => {
+            throw new Error('outer failure');
+        });
         await runner.run();
-        (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro: {}');
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalledTimes(1);
     });
 });

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

@@ -1,6 +1,25 @@
 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,6 +1,15 @@
 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;
@@ -9,8 +18,22 @@ 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,6 +3,15 @@ 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;
@@ -17,6 +26,11 @@ 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.');
@@ -26,6 +40,9 @@ 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();
@@ -66,15 +83,22 @@ 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) {
-            this.timeout(this.options.processTimeoutSeconds);
+            promises.push(this.timeout(this.options.processTimeoutSeconds));
         }
-        await this.process();
+        await Promise.race(promises);
     }
 }
 exports.SQSScaledJobRunner = SQSScaledJobRunner;

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

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

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const { sendMock } = vitest_1.vi.hoisted(() => ({
+    sendMock: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('@aws-sdk/client-sqs', () => ({
+    ReceiveMessageCommand: class ReceiveMessageCommand {
+        input;
+        constructor(input) {
+            this.input = input;
+        }
+    },
+    DeleteMessageCommand: class DeleteMessageCommand {
+        input;
+        constructor(input) {
+            this.input = input;
+        }
+    },
+    SQSClient: class SQSClient {
+        config;
+        send = sendMock;
+        constructor(config) {
+            this.config = config;
+        }
+    },
+}));
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const handler_1 = tslib_1.__importDefault(require("../../../application/queue/handler"));
+const runner_1 = require("./runner");
+class TestHandler extends handler_1.default {
+    handleMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+    constructor(simultaneity = 1, timeoutPerMessageSeconds) {
+        super();
+        this.simultaneity = simultaneity;
+        this.timeoutPerMessageSeconds = timeoutPerMessageSeconds;
+    }
+    async handle(message) {
+        await this.handleMock(message);
+    }
+}
+const createLogger = () => ({
+    info: vitest_1.vi.fn(),
+    warn: vitest_1.vi.fn(),
+    error: vitest_1.vi.fn(),
+    debug: vitest_1.vi.fn(),
+});
+(0, vitest_1.describe)('SQSScaledJobRunner', () => {
+    (0, vitest_1.beforeEach)(() => {
+        sendMock.mockReset();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should receive, process and delete messages from SQS', async () => {
+        vitest_1.vi.useFakeTimers();
+        const handler = new TestHandler(1, 1);
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+            waitMessagesTimeSeconds: 5,
+        }, logger);
+        sendMock
+            .mockResolvedValueOnce({
+            Messages: [
+                {
+                    Body: JSON.stringify({ id: '1' }),
+                    ReceiptHandle: 'receipt-handle',
+                },
+            ],
+        })
+            .mockResolvedValueOnce({});
+        const processPromise = runner.process();
+        await vitest_1.vi.runAllTimersAsync();
+        await processPromise;
+        (0, vitest_1.expect)(sendMock).toHaveBeenNthCalledWith(1, vitest_1.expect.any(client_sqs_1.ReceiveMessageCommand));
+        (0, vitest_1.expect)(sendMock.mock.calls[0][0].input).toEqual({
+            QueueUrl: 'queue-url',
+            MaxNumberOfMessages: 1,
+            WaitTimeSeconds: 5,
+        });
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledWith({ id: '1' });
+        (0, vitest_1.expect)(sendMock).toHaveBeenNthCalledWith(2, vitest_1.expect.any(client_sqs_1.DeleteMessageCommand));
+        (0, vitest_1.expect)(sendMock.mock.calls[1][0].input).toEqual({
+            QueueUrl: 'queue-url',
+            ReceiptHandle: 'receipt-handle',
+        });
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Mensagem processada com sucesso');
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Mensagem deletada');
+    });
+    (0, vitest_1.it)('should keep polling until simultaneity is reached when there are no messages', async () => {
+        const handler = new TestHandler(2);
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, logger);
+        sendMock.mockResolvedValue({
+            Messages: [],
+        });
+        await runner.process();
+        (0, vitest_1.expect)(sendMock).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Nenhuma mensagem disponível.');
+        (0, vitest_1.expect)(handler.handleMock).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should log invalid messages and guard the parser against unsupported inputs', async () => {
+        const handler = new TestHandler();
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, logger);
+        sendMock.mockResolvedValueOnce({
+            Messages: [
+                {
+                    Body: null,
+                    ReceiptHandle: 'receipt-handle',
+                },
+            ],
+        });
+        await runner.process();
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('[SQSScaledJobRunner] Erro:'));
+        (0, vitest_1.expect)(handler.handleMock).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(() => runner_1.SQSScaledJobRunner.parseMessage(undefined)).toThrow('[SQSScaledJobRunner] Mensagem inválida.');
+        (0, vitest_1.expect)(() => runner_1.SQSScaledJobRunner.parseMessage(123)).toThrow('[SQSScaledJobRunner] Mensagem deve ser uma string.');
+    });
+    (0, vitest_1.it)('should race processing with the global timeout when configured', async () => {
+        const runner = new runner_1.SQSScaledJobRunner(new TestHandler(), 'queue-url', {
+            sqsRegion: 'us-east-1',
+            processTimeoutSeconds: 3,
+        }, createLogger());
+        const processSpy = vitest_1.vi
+            .spyOn(runner, 'process')
+            .mockImplementation(() => new Promise(() => undefined));
+        const timeoutSpy = vitest_1.vi
+            .spyOn(runner, 'timeout')
+            .mockResolvedValue(undefined);
+        await runner.run();
+        (0, vitest_1.expect)(processSpy).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(timeoutSpy).toHaveBeenCalledWith(3);
+    });
+    (0, vitest_1.it)('should run processing directly when no global timeout is configured', async () => {
+        const runner = new runner_1.SQSScaledJobRunner(new TestHandler(), 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, createLogger());
+        const processSpy = vitest_1.vi.spyOn(runner, 'process').mockResolvedValue(undefined);
+        await runner.run();
+        (0, vitest_1.expect)(processSpy).toHaveBeenCalledTimes(1);
+    });
+});