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

package/dist/clean-arch/domain/entities/entity.d.ts

@@ -6,7 +6,4 @@ export declare abstract class Entity<Props> {
     set id(id: UniqueEntityId);
     protected constructor(props: Props, id?: UniqueEntityId);
     equals(entity: Entity<any>): boolean;
-    private serializeValue;
-    toObject(): Record<string, unknown>;
-    toEventDispatchObject(): Record<string, unknown>;
 }

package/dist/clean-arch/domain/entities/entity.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
 const unique_entity_id_1 = require("./unique-entity-id");
-const watched_list_1 = require("./watched-list");
 class Entity {
     _id;
     props;
@@ -25,39 +24,5 @@ class Entity {
         }
         return false;
     }
-    serializeValue(value) {
-        if (value instanceof Entity) {
-            return value.toObject();
-        }
-        if (value instanceof Date) {
-            return value.toISOString();
-        }
-        if (value instanceof unique_entity_id_1.UniqueEntityId) {
-            return value.toString();
-        }
-        if (value instanceof watched_list_1.WatchedList) {
-            return value.toObject();
-        }
-        if (Array.isArray(value)) {
-            return value.map(item => this.serializeValue(item));
-        }
-        if (value && typeof value === 'object') {
-            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-                key,
-                this.serializeValue(item),
-            ]));
-        }
-        return value;
-    }
-    toObject() {
-        const object = this.serializeValue(this.props);
-        return {
-            ...object,
-            id: this.id.toString(),
-        };
-    }
-    toEventDispatchObject() {
-        return this.toObject();
-    }
 }
 exports.Entity = Entity;

package/dist/clean-arch/domain/entities/watched-list.d.ts

@@ -22,5 +22,4 @@ export declare abstract class WatchedList<T> {
     add(item: T): void;
     remove(item: T): void;
     update(items: T[]): void;
-    toObject(): (T | Record<string, unknown>)[];
 }

package/dist/clean-arch/domain/entities/watched-list.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WatchedList = void 0;
-const entity_1 = require("./entity");
 class WatchedList {
     currentItems;
     initial;
@@ -90,13 +89,5 @@ class WatchedList {
         this.removed = removedItems;
         this.updated = updatedItems;
     }
-    toObject() {
-        return this.currentItems.map(item => {
-            if (item instanceof entity_1.Entity) {
-                return item.toObject();
-            }
-            return item;
-        });
-    }
 }
 exports.WatchedList = WatchedList;

package/dist/clean-arch/domain/events/domain-event.d.ts

@@ -1,8 +1,3 @@
-/**
- * Contrato mínimo de um evento de domínio publicado em filas.
- *
- * O campo `name` é usado como routing key no AMQP por convenção.
- */
 export default interface DomainEvent {
     name: string;
     eventDate: Date;

package/dist/clean-arch/domain/interfaces/country.d.ts

@@ -1,5 +1,4 @@
 export interface Country {
     code: string;
-    alpha2?: string;
     name: string;
 }

package/dist/clean-arch/infra/authorizations/authorizer.spec.js

@@ -142,47 +142,4 @@ describe('Authorizer', () => {
         });
         expect(response.data).toEqual({ message: 'ok' });
     });
-    it('should be able to fallback to auths header', async () => {
-        let Test = class Test {
-            async handle(_) {
-                return {
-                    data: { message: 'ok' },
-                };
-            }
-        };
-        Test = tslib_1.__decorate([
-            (0, authorizer_1.default)({ $and: ['arch.user.create'] })
-        ], Test);
-        const controller = new Test();
-        const response = await controller.handle({
-            headers: {
-                auths: JSON.stringify(['arch.user.create']),
-            },
-            body: {},
-            params: {},
-            query: {},
-        });
-        expect(response.data).toEqual({ message: 'ok' });
-    });
-    it('should return error when authorizations header is invalid JSON', async () => {
-        let Test = class Test {
-            async handle(_) {
-                return {
-                    data: { message: 'ok' },
-                };
-            }
-        };
-        Test = tslib_1.__decorate([
-            (0, authorizer_1.default)({ $and: ['arch.user.create'] })
-        ], Test);
-        const controller = new Test();
-        await expect(() => controller.handle({
-            headers: {
-                authorizations: 'invalid-json',
-            },
-            body: {},
-            params: {},
-            query: {},
-        })).rejects.toBeInstanceOf(Error);
-    });
 });

package/dist/clean-arch/infra/cache/cache-in-memory.d.ts

@@ -1,12 +1,7 @@
 import { Cache } from '../../application/cache/cache';
 import { CacheClient } from '../../application/cache/client';
-/**
- * Cache em memoria pronto para uso na lib.
- * Usa NodeCache como cliente.
- */
 declare class LibCache extends Cache {
     protected client: CacheClient;
 }
-/** Singleton do cache em memoria. */
 declare const libCacheInstance: LibCache;
 export default libCacheInstance;

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

@@ -2,15 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const cache_1 = require("../../application/cache/cache");
 const node_cache_1 = require("./clients/node-cache");
-/**
- * Cache em memoria pronto para uso na lib.
- * Usa NodeCache como cliente.
- */
 class LibCache extends cache_1.Cache {
     client = new node_cache_1.NodeCache();
 }
-/** Singleton do cache em memoria. */
 const libCacheInstance = new LibCache();
-/** Inicializa no import. */
 libCacheInstance.start();
 exports.default = libCacheInstance;

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

@@ -1,32 +1,15 @@
 import { CacheClient } from '../../../application/cache/client';
-/**
- * Cliente em memoria (NodeCache).
- * Ideal para ambientes locais, testes ou quando o cache nao precisa ser compartilhado.
- */
 export declare class NodeCache extends CacheClient {
     private client;
-    /** Inicializa o cache em memoria. */
     start(): Promise<void>;
-    /** Busca uma chave e faz JSON.parse do valor. */
     get(key: string): Promise<any>;
-    /**
-     * Guard simples para evitar crescimento indefinido.
-     * Limite atual: 50MB somando vsize + ksize.
-     */
     protected hasFreeMemory(): boolean;
-    /** Grava um valor com TTL em segundos. */
     set(key: string, data: string, expiration: number): Promise<void>;
-    /** Remove uma chave. */
     del(keyCache: string): Promise<void>;
-    /** Remove varias chaves. */
     delBatch(keyCache: string[]): Promise<void>;
-    /** Lista chaves; se pattern existir, filtra via RegExp. */
     getKeys(pattern?: string | undefined): Promise<string[]>;
-    /** Encerra e limpa a instancia. */
     close(): Promise<void>;
-    /** Limpa a instancia. */
     flush(): Promise<void>;
 }
-/** Instancia padrao do NodeCache (opcional). */
 declare const _default: NodeCache;
 export default _default;

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

@@ -4,27 +4,17 @@ exports.NodeCache = void 0;
 const tslib_1 = require("tslib");
 const node_cache_1 = tslib_1.__importDefault(require("node-cache"));
 const client_1 = require("../../../application/cache/client");
-/**
- * Cliente em memoria (NodeCache).
- * Ideal para ambientes locais, testes ou quando o cache nao precisa ser compartilhado.
- */
 class NodeCache extends client_1.CacheClient {
     client;
-    /** Inicializa o cache em memoria. */
     async start() {
         this.client = new node_cache_1.default();
     }
-    /** Busca uma chave e faz JSON.parse do valor. */
     async get(key) {
         const data = await this.client.get(key);
         if (!data)
             return null;
         return JSON.parse(data);
     }
-    /**
-     * Guard simples para evitar crescimento indefinido.
-     * Limite atual: 50MB somando vsize + ksize.
-     */
     hasFreeMemory() {
         const maxSizeMB = 50;
         const maxSizeByte = maxSizeMB * 1000000;
@@ -32,37 +22,29 @@ class NodeCache extends client_1.CacheClient {
         const currentSize = stats.vsize + stats.ksize;
         return currentSize < maxSizeByte;
     }
-    /** Grava um valor com TTL em segundos. */
     async set(key, data, expiration) {
         if (!this.hasFreeMemory())
             return;
         this.client.set(key, data, expiration);
     }
-    /** Remove uma chave. */
     async del(keyCache) {
         this.client.del(keyCache);
     }
-    /** Remove varias chaves. */
     async delBatch(keyCache) {
-        await Promise.all(keyCache.map(key => this.del(key)));
+        await Promise.all(keyCache.map(this.del));
     }
-    /** Lista chaves; se pattern existir, filtra via RegExp. */
     async getKeys(pattern) {
         const keys = this.client.keys();
         if (!pattern)
             return keys;
-        const regex = new RegExp(pattern);
-        return keys.filter(key => regex.test(key));
+        return keys.filter(new RegExp(pattern).test);
     }
-    /** Encerra e limpa a instancia. */
     async close() {
         this.client.flushAll();
     }
-    /** Limpa a instancia. */
     async flush() {
         return await this.client.flushAll();
     }
 }
 exports.NodeCache = NodeCache;
-/** Instancia padrao do NodeCache (opcional). */
 exports.default = new NodeCache();

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

@@ -3,34 +3,19 @@ import { CacheClient, CacheClientOptions } from '../../../application/cache/clie
 export type ListenersType = {
     error?: (error: Error) => void;
 } | undefined;
-/**
- * Opcoes do cliente Redis.
- * Combina opcoes do ioredis com CacheClientOptions.
- */
 export interface RedisOptions extends LibRedisOptions, CacheClientOptions {
 }
-/**
- * Cliente Redis para a camada de cache.
- */
 export declare class Redis extends CacheClient {
     protected connection: RedisOptions;
     private client;
     constructor(connection: RedisOptions);
     private delayOperation;
-    /** Inicializa o cliente Redis. */
     start(): Promise<void>;
-    /** Busca uma chave e faz JSON.parse do valor. */
     get(key: string): Promise<any>;
-    /** Grava uma chave com TTL em segundos. */
     set(key: string, data: string, expiration?: number): Promise<void>;
-    /** Remove uma chave. */
     del(keyCache: string): Promise<void>;
-    /** Remove varias chaves com pipeline. */
     delBatch(keyCache: string[]): Promise<void>;
-    /** Lista chaves (pattern no formato do Redis). */
     getKeys(pattern?: string | undefined): Promise<string[] | null>;
-    /** Limpa o banco atual do Redis. */
     flush(): Promise<void>;
-    /** Fecha a conexao com o Redis. */
     close(): Promise<void>;
 }

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

@@ -4,9 +4,6 @@ exports.Redis = void 0;
 const tslib_1 = require("tslib");
 const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
 const client_1 = require("../../../application/cache/client");
-/**
- * Cliente Redis para a camada de cache.
- */
 class Redis extends client_1.CacheClient {
     connection;
     client;
@@ -22,11 +19,9 @@ class Redis extends client_1.CacheClient {
         await new Promise(resolve => setTimeout(resolve, timeout || 2500));
         return null;
     }
-    /** Inicializa o cliente Redis. */
     async start() {
         this.client = new ioredis_1.default(this.connection);
     }
-    /** Busca uma chave e faz JSON.parse do valor. */
     async get(key) {
         const get = async () => {
             const data = await this.client.get(key);
@@ -37,7 +32,6 @@ class Redis extends client_1.CacheClient {
         // If redis not connected the get method never returns
         return await Promise.race([get(), this.delayOperation()]);
     }
-    /** Grava uma chave com TTL em segundos. */
     async set(key, data, expiration) {
         const set = async () => {
             if (expiration)
@@ -47,11 +41,9 @@ class Redis extends client_1.CacheClient {
         // If redis not connected the set method never returns
         await Promise.race([set(), this.delayOperation()]);
     }
-    /** Remove uma chave. */
     async del(keyCache) {
         await Promise.race([this.client.del(keyCache), this.delayOperation()]);
     }
-    /** Remove varias chaves com pipeline. */
     async delBatch(keyCache) {
         const delBatch = async () => {
             const pipeline = this.client.pipeline();
@@ -60,18 +52,15 @@ class Redis extends client_1.CacheClient {
         };
         await Promise.race([delBatch(), this.delayOperation()]);
     }
-    /** Lista chaves (pattern no formato do Redis). */
     async getKeys(pattern) {
         return await Promise.race([
             this.client.keys(pattern || '*'),
             this.delayOperation(),
         ]);
     }
-    /** Limpa o banco atual do Redis. */
     async flush() {
         await this.client.flushdb();
     }
-    /** Fecha a conexao com o Redis. */
     async close() {
         await Promise.race([this.client.quit(), this.delayOperation()]);
     }

package/dist/clean-arch/infra/http/controller.spec.js

@@ -1,179 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const api_error_1 = require("../../../infra/http/errors/api-error");
-const application_error_1 = tslib_1.__importDefault(require("../../domain/errors/application-error"));
 const conflict_error_1 = tslib_1.__importDefault(require("../../domain/errors/conflict-error"));
-const domain_error_1 = tslib_1.__importDefault(require("../../domain/errors/domain-error"));
-const validation_error_1 = tslib_1.__importDefault(require("../../domain/errors/validation-error"));
-const not_allowed_1 = tslib_1.__importDefault(require("../authorizations/not-allowed"));
-const infra_error_1 = tslib_1.__importDefault(require("../errors/infra-error"));
 const controller_1 = tslib_1.__importDefault(require("./controller"));
-class TestController extends controller_1.default {
-    async handle() {
-        return this.success({ ok: true });
+test('conflict error with one object', async () => {
+    class ControllerError extends controller_1.default {
+        async handle() {
+            try {
+                throw new conflict_error_1.default({ id: 'ID' });
+            }
+            catch (err) {
+                return this.throw(err);
+            }
+        }
     }
-    successResponse(dto) {
-        return this.success(dto);
-    }
-    noContentResponse() {
-        return this.noContent();
-    }
-    createdResponse(dto) {
-        return this.created(dto);
-    }
-    paginatedResponse(dto) {
-        return this.paginated(dto);
-    }
-}
-describe('Controller', () => {
-    it('should build success responses', () => {
-        const controller = new TestController();
-        expect(controller.successResponse({ id: '1' })).toEqual({
-            code: 200,
-            data: { data: { id: '1' } },
-        });
-        expect(controller.noContentResponse()).toEqual({
-            code: 204,
-            data: undefined,
-        });
-        expect(controller.createdResponse({ id: '1' })).toEqual({
-            code: 201,
-            data: { data: { id: '1' } },
-        });
-        expect(controller.createdResponse()).toEqual({
-            code: 201,
-            data: undefined,
-        });
-        expect(controller.paginatedResponse({ items: [1, 2] })).toEqual({
-            code: 200,
-            data: { items: [1, 2] },
-        });
-    });
-    it('should return conflict error response with one object', () => {
-        const controller = new TestController();
-        expect(controller.throw(new conflict_error_1.default({ id: 'ID' }))).toEqual({
+    const executeController = new ControllerError();
+    const responseError = await executeController.handle();
+    expect(responseError).toEqual(expect.objectContaining({
+        code: 409,
+        data: {
             code: 409,
-            data: {
-                code: 409,
-                message: 'Entity already exists.',
-                items: [{ id: 'ID' }],
-            },
-        });
-    });
-    it('should return conflict error response with array of objects', () => {
-        const controller = new TestController();
-        expect(controller.throw(new conflict_error_1.default([{ id: 'ID 1' }, { id: 'ID 2' }]))).toEqual({
+            message: 'Entity already exists.',
+            items: [
+                {
+                    id: 'ID',
+                },
+            ],
+        },
+    }));
+});
+test('conflict error with array of objects', async () => {
+    class ControllerError extends controller_1.default {
+        async handle() {
+            try {
+                throw new conflict_error_1.default([{ id: 'ID 1' }, { id: 'ID 2' }]);
+            }
+            catch (err) {
+                return this.throw(err);
+            }
+        }
+    }
+    const executeController = new ControllerError();
+    const responseError = await executeController.handle();
+    expect(responseError).toEqual(expect.objectContaining({
+        code: 409,
+        data: {
             code: 409,
-            data: {
-                code: 409,
-                message: 'Entity already exists.',
-                items: [{ id: 'ID 1' }, { id: 'ID 2' }],
-            },
-        });
-    });
-    it.each([
-        [new domain_error_1.default('domain failed', 422), 422, 'domain failed'],
-        [
-            new application_error_1.default('application failed', 401),
-            401,
-            'application failed',
-        ],
-        [new infra_error_1.default('infra failed', 503), 503, 'infra failed'],
-    ])('should map known error types with code and message', (error, code, message) => {
-        const controller = new TestController();
-        expect(controller.throw(error)).toEqual({
-            code,
-            data: {
-                code,
-                message,
-            },
-        });
-    });
-    it('should map api errors', () => {
-        const controller = new TestController();
-        const error = new api_error_1.ApiError({
-            status: 401,
-            body: {
-                code: 401,
-                message: 'Unauthorized',
-                timestamp: new Date('2024-01-01T00:00:00.000Z'),
-                errors: [
-                    {
-                        code_error: '401',
-                        location: 'authorization',
-                        msg: 'Unauthorized',
-                    },
-                ],
-            },
-            headers: {},
-        });
-        expect(controller.throw(error)).toEqual({
-            code: 401,
-            data: error.error,
-        });
-    });
-    it('should map validation errors', () => {
-        const controller = new TestController();
-        const error = new validation_error_1.default([
-            {
-                property: 'email',
-                message: 'Required field',
-            },
-        ]);
-        expect(controller.throw(error)).toEqual({
-            code: 400,
-            data: {
-                code: 400,
-                message: 'Validation Error',
-                errors: [
-                    {
-                        property: 'email',
-                        message: 'Required field',
-                    },
-                ],
-            },
-        });
-    });
-    it('should map not allowed errors', () => {
-        const controller = new TestController();
-        const error = new not_allowed_1.default({
-            status: 403,
-            body: {
-                code: 403,
-                message: 'Forbidden',
-                timestamp: new Date('2024-02-02T00:00:00.000Z'),
-                errors: [
-                    {
-                        code_error: '403',
-                        location: 'authorization',
-                        msg: 'Forbidden',
-                    },
-                ],
-            },
-            headers: {
-                'content-type': 'application/json',
-            },
-        });
-        expect(controller.throw(error)).toEqual({
-            code: 403,
-            data: error.error,
-        });
-    });
-    it('should map unexpected errors to internal server error', () => {
-        const controller = new TestController();
-        const unexpectedError = new Error('boom');
-        const consoleError = vi
-            .spyOn(console, 'error')
-            .mockImplementation(() => undefined);
-        expect(controller.throw(unexpectedError)).toEqual({
-            code: 500,
-            data: {
-                code: 500,
-                message: 'Server failed. Contact the administrator!',
-                reason: unexpectedError,
-            },
-        });
-        expect(consoleError).toHaveBeenCalledWith(unexpectedError);
-    });
+            message: 'Entity already exists.',
+            items: [
+                {
+                    id: 'ID 1',
+                },
+                {
+                    id: 'ID 2',
+                },
+            ],
+        },
+    }));
 });

package/dist/clean-arch/infra/http/handle-user-headers.d.ts

@@ -1,16 +1,11 @@
 type HeadersProps = {
     username: string;
     useremail: string;
-    userid?: string;
-    ['app-id']?: string;
-    tenantid: string;
 };
 export declare function handleUserHeaders(headers: HeadersProps): {
     createdByName: string;
     createdByEmail: string;
     updatedByEmail: string;
     updatedByName: string;
-    entityId: string | undefined;
-    tenantId: string;
 };
 export {};

package/dist/clean-arch/infra/http/handle-user-headers.js

@@ -7,8 +7,6 @@ function handleUserHeaders(headers) {
         createdByEmail: headers.useremail,
         updatedByEmail: headers.useremail,
         updatedByName: headers.username,
-        entityId: headers.userid || headers['app-id'],
-        tenantId: headers.tenantid,
     };
 }
 exports.handleUserHeaders = handleUserHeaders;

package/dist/clean-arch/infra/logger/logger-in-memory.d.ts

@@ -1,40 +1,11 @@
+import LoggerGateway, { LogOptions, LogParams, LogPropertiesInput } from '../../application/logger';
 import { Cache } from '../../../clean-arch/application/cache/cache';
-import LoggerGateway, { LogOptions, LogPropertiesInput } from '../../application/logger';
-import { LogOrbitParamsInput } from './logger-orbit';
 export interface LoggerInMemoryOptions extends LogOptions {
-    /**
-     * Quando `true`, inclui as propriedades do log na saída do console.
-     * Útil para depuração local.
-     */
     showProps?: boolean;
 }
-export type LoggerInMemoryProps = {
-    cache?: Cache;
-    options?: LoggerInMemoryOptions;
-    params?: LogOrbitParamsInput;
-};
-/**
- * Logger simples que escreve no console.
- *
- * Observação: esta implementação NÃO persiste logs em memória.
- * O nome "InMemory" refere-se ao uso local/leve, sem dependências externas.
- */
 export declare class LoggerInMemory extends LoggerGateway {
     protected options: LoggerInMemoryOptions;
-    /**
-     * @param cache Cache opcional para filtro de nível (pode ser em memória ou Redis).
-     * @param options Opções de comportamento do logger.
-     * @param params Parâmetros padrão de log (actor/type).
-     */
-    constructor(props?: LoggerInMemoryProps);
-    /**
-     * Delegado para o fluxo comum de LoggerGateway.
-     * Mantido como atalho para compatibilidade com outros loggers.
-     */
+    constructor(cache?: Cache, options?: LoggerInMemoryOptions, params?: LogParams);
     log(props: LogPropertiesInput, dataToLog: any): Promise<void>;
-    /**
-     * Escreve no console usando o nível de log.
-     * Quando `showProps` é true, adiciona as props como último argumento.
-     */
     protected register(props: LogPropertiesInput, dataToLog: any): void;
 }