@seidor-cloud-produtos/orbit-backend-lib 2.0.18 → 2.0.20

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

@@ -25,4 +25,5 @@ export declare abstract class Cache {
     isRunning(options?: MethodOptions, isContingency?: boolean): Promise<boolean>;
     close(options?: MethodOptions): Promise<void>;
     protected handleException(e: Error): Promise<void>;
+    getOrFetchAndCache<T>(keyCache: string, expiration: number | undefined, promise: () => Promise<T>, options?: MethodOptions): Promise<T | undefined>;
 }

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

@@ -18,8 +18,8 @@ class Cache {
     }
     setElegibleClients(contingencyClients) {
         this.elegibleClients = [
-            this.client,
             ...(contingencyClients || []),
+            this.client,
         ];
     }
     setOptions(options) {
@@ -39,9 +39,12 @@ class Cache {
                 await currentClient.start();
                 isRunning = await currentClient.isRunning();
             }
-            catch (e) { }
+            catch { }
             if (isRunning) {
-                await this.client.close();
+                try {
+                    await this.client.close();
+                }
+                catch { }
                 this.client = currentClient;
                 break;
             }
@@ -164,5 +167,13 @@ class Cache {
         catch { }
         throw e;
     }
+    async getOrFetchAndCache(keyCache, expiration = this.DEFAULT_EXPIRATION_SECONDS, promise, options) {
+        let data = await this.get(keyCache, options);
+        if (!data) {
+            data = await promise();
+            this.set(keyCache, data, expiration, options);
+        }
+        return data;
+    }
 }
 exports.Cache = Cache;

package/dist/clean-arch/domain/entities/value-objects/cnpj.d.ts

@@ -0,0 +1,17 @@
+export default class Cnpj {
+    readonly value: string;
+    private constructor();
+    static create(cnpj: string): Cnpj;
+    static createCorrectly(cnpj: string): Cnpj;
+    private static tamanhoCNPJSemDV;
+    private static regexCNPJSemDV;
+    private static regexCNPJ;
+    private static regexMascara;
+    private static regexNaoPermitidos;
+    private static valorBase;
+    private static pesosDV;
+    private static cnpjZerado;
+    private static clear;
+    static isValid(input: string): boolean;
+    private static calculaDV;
+}

package/dist/clean-arch/domain/entities/value-objects/cnpj.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable no-useless-escape */
+const invalid_cnpj_error_1 = tslib_1.__importDefault(require("../../../domain/errors/invalid-cnpj-error"));
+class Cnpj {
+    value;
+    constructor(cnpj) {
+        this.value = cnpj;
+    }
+    static create(cnpj) {
+        if (!this.isValid(cnpj)) {
+            throw new invalid_cnpj_error_1.default(cnpj);
+        }
+        return new Cnpj(this.clear(cnpj));
+    }
+    static createCorrectly(cnpj) {
+        return new Cnpj(this.clear(cnpj));
+    }
+    static tamanhoCNPJSemDV = 12;
+    static regexCNPJSemDV = /^[A-Z0-9]{12}$/;
+    static regexCNPJ = /^[A-Z0-9]{12}\d{2}$/;
+    static regexMascara = /[.\/-]/g;
+    static regexNaoPermitidos = /[^A-Z0-9.\/-]/i;
+    static valorBase = '0'.charCodeAt(0);
+    static pesosDV = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    static cnpjZerado = '0'.repeat(14);
+    static clear(input) {
+        return input.replace(this.regexMascara, '').toUpperCase();
+    }
+    static isValid(input) {
+        if (this.regexNaoPermitidos.test(input))
+            return false;
+        const raw = this.clear(input);
+        if (raw.length !== 14 || raw === this.cnpjZerado)
+            return false;
+        if (!this.regexCNPJ.test(raw))
+            return false;
+        const base = raw.substring(0, this.tamanhoCNPJSemDV);
+        const dvInformado = raw.substring(this.tamanhoCNPJSemDV);
+        const dvCalculado = this.calculaDV(base);
+        return dvInformado === dvCalculado;
+    }
+    static calculaDV(base) {
+        if (!this.regexCNPJSemDV.test(base)) {
+            throw new Error('Base do CNPJ inválida para cálculo de DV');
+        }
+        let soma1 = 0;
+        let soma2 = 0;
+        for (let i = 0; i < this.tamanhoCNPJSemDV; i++) {
+            const valor = base.charCodeAt(i) - this.valorBase;
+            soma1 += valor * this.pesosDV[i + 1];
+            soma2 += valor * this.pesosDV[i];
+        }
+        const dv1 = soma1 % 11 < 2 ? 0 : 11 - (soma1 % 11);
+        soma2 += dv1 * this.pesosDV[this.tamanhoCNPJSemDV];
+        const dv2 = soma2 % 11 < 2 ? 0 : 11 - (soma2 % 11);
+        return `${dv1}${dv2}`;
+    }
+}
+exports.default = Cnpj;

package/dist/clean-arch/domain/entities/value-objects/cnpj.spec.d.ts

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

package/dist/clean-arch/domain/entities/value-objects/cnpj.spec.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const invalid_cnpj_error_1 = tslib_1.__importDefault(require("../../errors/invalid-cnpj-error"));
+const cnpj_1 = tslib_1.__importDefault(require("./cnpj"));
+describe('Value Object - Cnpj', () => {
+    it('should be able to crete a new cnpj (numeric)', () => {
+        const cnpj = cnpj_1.default.create('46230439000101');
+        expect(cnpj.value).toBe('46230439000101');
+    });
+    it('should be able to return error when cnpj is wrong', () => {
+        expect(() => cnpj_1.default.create('12344556')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should be able to return error when cnpj only has one number', () => {
+        expect(() => cnpj_1.default.create('11111111111111')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should be able to return error when digit 0 is diff', () => {
+        expect(() => cnpj_1.default.create('46230439000111')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should be able to create correctly without validation', () => {
+        const cnpj = cnpj_1.default.createCorrectly('46230439000101');
+        expect(cnpj.value).toBe('46230439000101');
+    });
+    // --- cenários alfanuméricos existentes ---
+    it('should be able to create a valid alphanumeric cnpj (plain)', () => {
+        const raw = '12ABC34501DE35';
+        const cnpj = cnpj_1.default.create(raw);
+        expect(cnpj.value).toBe(raw);
+    });
+    it('should be able to create a valid alphanumeric cnpj (formatted)', () => {
+        const formatted = '12.ABC.345/01DE-35';
+        const cnpj = cnpj_1.default.create(formatted);
+        expect(cnpj.value).toBe('12ABC34501DE35');
+    });
+    it('should throw for alphanumeric cnpj with wrong check digit', () => {
+        expect(() => cnpj_1.default.create('12ABC34501DE36')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should throw for alphanumeric cnpj with invalid character', () => {
+        expect(() => cnpj_1.default.create('12AB@34501DE35')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should throw for alphanumeric cnpj too short', () => {
+        expect(() => cnpj_1.default.create('12ABC34501D')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should throw for cnpj all zeros', () => {
+        expect(() => cnpj_1.default.create('00000000000000')).toThrow(invalid_cnpj_error_1.default);
+    });
+    it('should accept lowercase alphanumeric cnpj and normalize to uppercase', () => {
+        const lower = '12abc34501de35';
+        const cnpj = cnpj_1.default.create(lower);
+        expect(cnpj.value).toBe('12ABC34501DE35');
+    });
+    it('createCorrectly should remove mask from formatted alphanumeric cnpj without validating', () => {
+        const formatted = '12.ABC.345/01DE-XX'; // invalid DV/characters but mask is removed
+        const cnpj = cnpj_1.default.createCorrectly(formatted);
+        expect(cnpj.value).toBe('12ABC34501DEXX');
+    });
+});

package/dist/clean-arch/domain/errors/invalid-cnpj-error.d.ts

@@ -0,0 +1,4 @@
+import DomainError from './domain-error';
+export default class InvalidCnpjError extends DomainError {
+    constructor(cnpj: string);
+}

package/dist/clean-arch/domain/errors/invalid-cnpj-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const domain_error_1 = tslib_1.__importDefault(require("./domain-error"));
+class InvalidCnpjError extends domain_error_1.default {
+    constructor(cnpj) {
+        super(`The cnpj "${cnpj}" is invalid.`, 400);
+        this.name = 'InvalidCnpjError';
+    }
+}
+exports.default = InvalidCnpjError;

package/dist/clean-arch/infra/cache/clients/redis.d.ts

@@ -1,5 +1,8 @@
 import { RedisOptions as LibRedisOptions } from 'ioredis';
 import { CacheClient, CacheClientOptions } from '../../../application/cache/client';
+export type ListenersType = {
+    error?: (error: Error) => void;
+} | undefined;
 export interface RedisOptions extends LibRedisOptions, CacheClientOptions {
 }
 export declare class Redis extends CacheClient {

package/dist/clean-arch/infra/cache/clients/redis.js

@@ -62,7 +62,7 @@ class Redis extends client_1.CacheClient {
         await this.client.flushdb();
     }
     async close() {
-        await this.client.quit();
+        await Promise.race([this.client.quit(), this.delayOperation()]);
     }
 }
 exports.Redis = Redis;

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

@@ -12,7 +12,9 @@ export default class AmqpQueue implements QueueConnection {
     private messagesInMemory;
     private controller;
     private channels;
-    constructor(uri?: string);
+    protected socketOptions?: any;
+    constructor(uri?: string, socketOptions?: any);
+    private setSocketOptions;
     connect(vHost: string): Promise<AmqpQueue>;
     close(): Promise<void>;
     get(queueName: string, options?: amqp.Options.Get | undefined): Promise<AmqpQueueGetResult | null>;

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

@@ -10,12 +10,18 @@ class AmqpQueue {
     messagesInMemory = [];
     controller;
     channels = new Map();
-    constructor(uri = process.env.BROKER_AMQP) {
+    socketOptions;
+    constructor(uri = process.env.BROKER_AMQP, socketOptions) {
         this.uri = uri;
+        this.setSocketOptions(socketOptions);
+    }
+    setSocketOptions(socketOptions) {
+        this.socketOptions = socketOptions;
+        return this;
     }
     async connect(vHost) {
         const urlConnection = `${this.uri}${vHost === '/' ? '/' : `/${vHost}`}`;
-        this.connection = await amqplib_1.default.connect(urlConnection);
+        this.connection = await amqplib_1.default.connect(urlConnection, this.socketOptions);
         this.vHost = vHost;
         await this.treatReconnection(vHost);
         if (process.env.NODE_ENV !== 'test') {

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

@@ -2,15 +2,13 @@ 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';
-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);
+    constructor(amqpQueue: AmqpQueue, queueName: string, vHost: string, handler: Handler, options: RabbitMQScaledJobOptions);
     private handleError;
     protected errorStrategy(getResult: AmqpQueueGetResult): Promise<void>;
     private rejectTimeout;

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

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RabbitMQScaledJobRunner = void 0;
+const tslib_1 = require("tslib");
+const logger_in_memory_1 = tslib_1.__importDefault(require("../logger/logger-in-memory"));
 class RabbitMQScaledJobRunner {
     amqpQueue;
     queueName;
     vHost;
     handler;
     options;
-    logger;
-    constructor(amqpQueue, queueName, vHost, handler, options, logger) {
+    constructor(amqpQueue, queueName, vHost, handler, options) {
         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;
         }
@@ -32,46 +31,66 @@ class RabbitMQScaledJobRunner {
             return await this.amqpQueue.nack(channel, rawMessage, false);
         }
         catch {
-            this.logger.log('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
+            logger_in_memory_1.default.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');
+        logger_in_memory_1.default.debug()?.log('[RabbitMQScaledJobRunner] Finished process');
     }
     async run() {
         let getResult = null;
+        let consumedMessages = 0;
+        const messagesToGet = this.options.numberOfMessagesToGet ?? 1;
         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);
+            while (consumedMessages < messagesToGet) {
+                try {
+                    getResult = await this.amqpQueue.get(this.queueName, {
+                        noAck: !this.options.manualAck,
+                    });
+                    if (!getResult) {
+                        logger_in_memory_1.default.log('[RabbitMQScaledJobRunner] Nenhuma mensagem disponível.');
+                        return;
+                    }
+                    const { channel, rawMessage } = getResult;
+                    const msg = this.options.parse(rawMessage);
+                    logger_in_memory_1.default
+                        .debug()
+                        ?.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 (error) {
+                    logger_in_memory_1.default.log(`[RabbitMQScaledJobRunner] Erro: ${error.message}`);
+                    if (getResult && this.options.manualAck) {
+                        await this.handleError(error, getResult);
+                    }
+                }
+                finally {
+                    if (getResult) {
+                        getResult = null;
+                        consumedMessages += 1;
+                        logger_in_memory_1.default
+                            .debug()
+                            ?.log(`[RabbitMQScaledJobRunner] Mensagens consumidas: ${consumedMessages}`);
+                    }
+                }
             }
         }
-        catch (err) {
-            this.logger.log(`[RabbitMQScaledJobRunner] Erro: ${err.message}`);
-            if (getResult && this.options.manualAck) {
-                await this.handleError(err, getResult);
-            }
+        catch (error) {
+            logger_in_memory_1.default.log(`[RabbitMQScaledJobRunner] Erro: ${JSON.stringify(error)}`);
         }
         finally {
             try {
                 await this.amqpQueue.close();
             }
             catch {
-                this.logger.log('[RabbitMQScaledJobRunner] Erro ao fechar conexão');
+                logger_in_memory_1.default.log('[RabbitMQScaledJobRunner] Erro ao fechar conexão');
                 await this.finishProcess();
             }
         }

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

@@ -2,12 +2,11 @@
 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 onFinally;
     let runner;
     (0, vitest_1.beforeEach)(() => {
         amqpQueue = {
@@ -24,7 +23,8 @@ const logger_in_memory_1 = require("../logger/logger-in-memory");
             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());
+        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') };
@@ -51,9 +51,7 @@ const logger_in_memory_1 = require("../logger/logger-in-memory");
         const rawMessage = { content: Buffer.from('msg') };
         const channel = {};
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw 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);
     });
@@ -62,9 +60,7 @@ const logger_in_memory_1 = require("../logger/logger-in-memory");
         const rawMessage = { content: Buffer.from('msg') };
         const channel = {};
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw 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, false);
     });
@@ -110,9 +106,7 @@ const logger_in_memory_1 = require("../logger/logger-in-memory");
         const rawMessage = { content: Buffer.from('msg') };
         const channel = {};
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw 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, false);
     });

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

@@ -4,4 +4,5 @@ export type RabbitMQScaledJobOptions = {
     manualAck: boolean;
     errorStrategy: ErrorStrategy;
     timeoutMs: number;
+    numberOfMessagesToGet?: number;
 };

package/dist/infra/authorizations/validator/auth-validator.js

@@ -16,8 +16,11 @@ class AuthValidator {
     isAuthorized() {
         const notReceiptAuthorizations = this.requestData.authorizations === undefined ||
             this.requestData.authorizations === null;
+        if (notReceiptAuthorizations) {
+            return true;
+        }
         const hasAuthorizations = auth_matcher_1.default.isMatch(this.query, this.requestData.authorizations);
-        return notReceiptAuthorizations || hasAuthorizations;
+        return hasAuthorizations;
     }
     async setup() {
         this.requestData = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -51,6 +51,7 @@
     "@types/compression": "1.7.5",
     "@types/cors": "2.8.17",
     "@types/express": "4.17.21",
+    "@types/jest": "30.0.0",
     "@types/supertest": "6.0.2",
     "@typescript-eslint/eslint-plugin": "5.59.9",
     "@typescript-eslint/parser": "5.59.9",
@@ -79,7 +80,7 @@
   "dependencies": {
     "@fastify/cors": "8.3.0",
     "@nestjs/common": "8.4.7",
-    "amqplib": "0.10.4",
+    "amqplib": "0.10.9",
     "axios": "1.8.2",
     "compression": "1.7.4",
     "discord.js": "14.16.3",