@seidor-cloud-produtos/orbit-backend-lib 0.0.98 → 0.0.12327

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

@@ -4,13 +4,17 @@ export type MethodOptions = {
 };
 export type CacheOptions = {
     throwOnError?: boolean;
+    contingencyClients?: CacheClient[];
 };
 export declare abstract class Cache {
-    protected abstract client: CacheClient;
+    protected client: CacheClient;
+    protected elegibleClients: CacheClient[];
     protected DEFAULT_EXPIRATION_SECONDS: number;
     private options?;
     constructor(options?: CacheOptions);
+    private setElegibleClients;
     private setOptions;
+    private setRunningClient;
     start(options?: MethodOptions): Promise<void>;
     get(keyCache: string, options?: MethodOptions): Promise<any>;
     set(keyCache: string, data: any, expiration?: number, options?: MethodOptions): Promise<void>;
@@ -18,6 +22,8 @@ export declare abstract class Cache {
     getKeys(pattern?: string, options?: MethodOptions): Promise<string[] | null>;
     delBatch(patterns: string[], options?: MethodOptions): Promise<void>;
     flush(): Promise<void>;
-    isRunning(options?: MethodOptions): Promise<any>;
+    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

@@ -2,14 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = void 0;
 const tslib_1 = require("tslib");
+const logger_in_memory_1 = tslib_1.__importDefault(require("../../infra/logger/logger-in-memory"));
 const env_1 = require("../../infra/environment/env");
-const logger_1 = tslib_1.__importDefault(require("../logger"));
+const types_1 = require("../../infra/environment/types");
 class Cache {
-    DEFAULT_EXPIRATION_SECONDS = env_1.env.DEFAULT_CACHE_EXPIRATION;
+    client;
+    elegibleClients;
+    DEFAULT_EXPIRATION_SECONDS = env_1.env?.DEFAULT_CACHE_EXPIRATION || 360;
     options;
     constructor(options) {
-        if (options)
+        if (options) {
             this.setOptions(options);
+            this.setElegibleClients(options.contingencyClients);
+        }
+    }
+    setElegibleClients(contingencyClients) {
+        this.elegibleClients = [
+            ...(contingencyClients || []),
+            this.client,
+        ];
     }
     setOptions(options) {
         this.options = {
@@ -17,17 +28,45 @@ class Cache {
             throwOnError: options.throwOnError === undefined ? true : options.throwOnError,
         };
     }
+    async setRunningClient() {
+        if (this.elegibleClients.length === 1) {
+            return this;
+        }
+        let isRunning = false;
+        for (let i = 0; i < this.elegibleClients.length; i++) {
+            const currentClient = this.elegibleClients[i];
+            try {
+                await currentClient.start();
+                isRunning = await currentClient.isRunning();
+            }
+            catch { }
+            if (isRunning) {
+                try {
+                    await this.client.close();
+                }
+                catch { }
+                this.client = currentClient;
+                break;
+            }
+            currentClient?.close();
+        }
+        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) {
         try {
             await this.client.start();
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
+            }
+            else {
+                await this.setRunningClient();
             }
             return;
         }
-        logger_1.default.debug()?.info('💾 Cache Connected');
+        await logger_in_memory_1.default.debug()?.log('💾 Cache Connected');
     }
     async get(keyCache, options) {
         try {
@@ -36,7 +75,7 @@ class Cache {
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return null;
         }
@@ -47,7 +86,7 @@ class Cache {
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return;
         }
@@ -58,7 +97,7 @@ class Cache {
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return;
         }
@@ -69,7 +108,7 @@ class Cache {
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return null;
         }
@@ -80,36 +119,61 @@ class Cache {
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return;
         }
     }
     async flush() {
-        return await this.client.flush();
+        try {
+            return await this.client.flush();
+        }
+        catch (e) {
+            await this.handleException(e);
+        }
     }
-    async isRunning(options) {
+    async isRunning(options, isContingency = false) {
+        let isRunning = false;
         try {
-            return await this.client.isRunning();
+            isRunning = await this.client.isRunning();
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
-            return false;
         }
+        if (!isRunning && !isContingency) {
+            await this.setRunningClient();
+            return await this.isRunning(options, true);
+        }
+        return isRunning;
     }
     async close(options) {
-        logger_1.default.debug()?.info('💾 Cache closed');
+        await logger_in_memory_1.default.debug()?.log('💾 Cache closed');
         try {
             return await this.client.close();
         }
         catch (e) {
             if (options?.throwOnError || this.options?.throwOnError) {
-                throw e;
+                await this.handleException(e);
             }
             return;
         }
     }
+    async handleException(e) {
+        try {
+            await logger_in_memory_1.default.log(JSON.stringify(e), { level: types_1.LOG_LEVEL.error });
+        }
+        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/application/cache/client.d.ts

@@ -1,4 +1,9 @@
+export interface CacheClientOptions {
+    timeout?: number;
+}
 export declare abstract class CacheClient {
+    protected connection?: CacheClientOptions | undefined;
+    constructor(connection?: CacheClientOptions | undefined);
     abstract start(): Promise<void>;
     abstract close(): Promise<void>;
     abstract get(keyCache: string): Promise<any>;

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

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheClient = void 0;
 const unique_entity_id_1 = require("../../domain/entities/unique-entity-id");
 class CacheClient {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
     async isRunning() {
         const key = new unique_entity_id_1.UniqueEntityId().toValue();
-        await this.set(key, JSON.stringify({ ping: true }), 60);
+        await this.set(key, JSON.stringify({ ping: true }), this.connection?.timeout || 60);
         const cachedData = await this.get(key);
         return cachedData?.ping || false;
     }

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

@@ -1,11 +1,31 @@
-export declare enum LOG_LEVEL {
-    debug = "DEBUG",
-    info = "INFO"
+import { LOG_LEVEL } from '../../infra/environment/types';
+export declare enum ActorEnum {
+    SYSTEM = "system",
+    USER = "user"
 }
-export declare class Logger {
-    debug(): this | undefined;
-    info(info: any): void;
-    error(error: any): void;
+export declare enum CategoryEnum {
+    BUSINESS = "business",
+    TECHNICAL = "technical"
+}
+export type LogProperties = {
+    id?: string;
+    actorType: ActorEnum;
+    category: CategoryEnum;
+    level: LOG_LEVEL;
+    actor: string;
+    type: string;
+    tenantId?: string;
+    dateTime?: Date;
+    expirationHours?: number;
+    trace?: {
+        mainId?: string;
+        ids: string[];
+    };
+};
+export interface LogOptions {
+    throwOnError?: boolean;
+    retryStrategy?: (data: any, props?: LogProperties, options?: LogOptions) => Promise<void>;
+}
+export default abstract class LoggerGateway {
+    abstract log(data: any, props?: LogProperties, options?: LogOptions): Promise<void>;
 }
-declare const logger: Logger;
-export default logger;

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

@@ -1,25 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.LOG_LEVEL = void 0;
-const env_1 = require("../../infra/environment/env");
-var LOG_LEVEL;
-(function (LOG_LEVEL) {
-    LOG_LEVEL["debug"] = "DEBUG";
-    LOG_LEVEL["info"] = "INFO";
-})(LOG_LEVEL || (exports.LOG_LEVEL = LOG_LEVEL = {}));
-class Logger {
-    debug() {
-        if (env_1.env.LOG_LEVEL === LOG_LEVEL.debug)
-            return this;
-        return undefined;
-    }
-    info(info) {
-        console.info(info);
-    }
-    error(error) {
-        console.error(error);
-    }
+exports.CategoryEnum = exports.ActorEnum = void 0;
+var ActorEnum;
+(function (ActorEnum) {
+    ActorEnum["SYSTEM"] = "system";
+    ActorEnum["USER"] = "user";
+})(ActorEnum || (exports.ActorEnum = ActorEnum = {}));
+var CategoryEnum;
+(function (CategoryEnum) {
+    CategoryEnum["BUSINESS"] = "business";
+    CategoryEnum["TECHNICAL"] = "technical";
+})(CategoryEnum || (exports.CategoryEnum = CategoryEnum = {}));
+class LoggerGateway {
 }
-exports.Logger = Logger;
-const logger = new Logger();
-exports.default = logger;
+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/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/conflict-error.d.ts

@@ -0,0 +1,10 @@
+type ConflictProps = {
+    id: string;
+    [key: string]: any;
+};
+export default class ConflictError<T extends ConflictProps> extends Error {
+    code: number;
+    props: T | T[];
+    constructor(props: T | T[]);
+}
+export {};

package/dist/clean-arch/domain/errors/conflict-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConflictError extends Error {
+    code;
+    props;
+    constructor(props) {
+        super('Entity already exists.');
+        this.code = 409;
+        this.props = props;
+    }
+}
+exports.default = ConflictError;

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/domain/errors/log-error.d.ts

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

package/dist/clean-arch/domain/errors/log-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 LogError extends domain_error_1.default {
+    constructor() {
+        super('Cannot log', 500);
+        this.name = 'LogError';
+    }
+}
+exports.default = LogError;