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

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

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const expressInstance = {
+    delete: vitest_1.vi.fn(),
+    disable: vitest_1.vi.fn(),
+    get: vitest_1.vi.fn(),
+    listen: vitest_1.vi.fn(),
+    patch: vitest_1.vi.fn(),
+    post: vitest_1.vi.fn(),
+    put: vitest_1.vi.fn(),
+    use: vitest_1.vi.fn(),
+};
+const fastifyInstance = {
+    close: vitest_1.vi.fn().mockResolvedValue(undefined),
+    delete: vitest_1.vi.fn(),
+    get: vitest_1.vi.fn(),
+    listen: vitest_1.vi.fn(),
+    patch: vitest_1.vi.fn(),
+    post: vitest_1.vi.fn(),
+    put: vitest_1.vi.fn(),
+    ready: vitest_1.vi.fn().mockResolvedValue(undefined),
+    register: vitest_1.vi.fn(),
+};
+vitest_1.vi.mock('cors', () => ({
+    default: vitest_1.vi.fn(() => 'cors-middleware'),
+}));
+vitest_1.vi.mock('compression', () => ({
+    default: vitest_1.vi.fn(() => 'compression-middleware'),
+}));
+vitest_1.vi.mock('express', () => {
+    const express = vitest_1.vi.fn(() => expressInstance);
+    express.json = vitest_1.vi.fn(() => 'json-middleware');
+    express.urlencoded = vitest_1.vi.fn(() => 'urlencoded-middleware');
+    return {
+        default: express,
+    };
+});
+vitest_1.vi.mock('@fastify/cors', () => ({
+    default: 'fastify-cors-plugin',
+}));
+vitest_1.vi.mock('fastify', () => ({
+    default: vitest_1.vi.fn(() => fastifyInstance),
+}));
+const compression_1 = tslib_1.__importDefault(require("compression"));
+const cors_1 = tslib_1.__importDefault(require("cors"));
+const express_1 = tslib_1.__importDefault(require("express"));
+const fastify_1 = tslib_1.__importDefault(require("fastify"));
+const express_adapter_1 = tslib_1.__importDefault(require("./express-adapter"));
+const fastify_adapter_1 = tslib_1.__importDefault(require("./fastify-adapter"));
+describe('HTTP adapters', () => {
+    afterEach(() => {
+        vitest_1.vi.clearAllMocks();
+        vitest_1.vi.restoreAllMocks();
+    });
+    it('should configure express and route requests', async () => {
+        let routeHandler;
+        const controller = {
+            handle: vitest_1.vi.fn().mockResolvedValue({
+                code: 201,
+                data: { id: '1' },
+            }),
+            throw: vitest_1.vi.fn(),
+        };
+        const response = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            json: vitest_1.vi.fn().mockReturnThis(),
+        };
+        const consoleLog = vitest_1.vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        expressInstance.post.mockImplementation((_url, handler) => {
+            routeHandler = handler;
+        });
+        expressInstance.listen.mockImplementation((_port, callback) => {
+            callback();
+            return {
+                close: vitest_1.vi.fn().mockResolvedValue(undefined),
+            };
+        });
+        const adapter = new express_adapter_1.default({
+            NODE_ENV: 'production',
+        });
+        expect(express_1.default).toHaveBeenCalledTimes(1);
+        expect(expressInstance.use).toHaveBeenCalledTimes(5);
+        expect(cors_1.default).toHaveBeenCalledTimes(1);
+        expect(compression_1.default).toHaveBeenCalledTimes(1);
+        expect(expressInstance.disable).toHaveBeenCalledWith('x-powered-by');
+        adapter.on('post', '/partners', controller);
+        await routeHandler({
+            body: { id: '1' },
+            params: { partnerId: '1' },
+            headers: { authorization: 'token' },
+            query: { page: '1' },
+        }, response);
+        expect(controller.handle).toHaveBeenCalledWith({
+            body: { id: '1' },
+            params: { partnerId: '1' },
+            headers: { authorization: 'token' },
+            query: { page: '1' },
+        });
+        expect(response.status).toHaveBeenCalledWith(201);
+        expect(response.json).toHaveBeenCalledWith({ id: '1' });
+        await adapter.listen(3333);
+        expect(expressInstance.listen).toHaveBeenCalledWith(3333, expect.any(Function));
+        expect(consoleLog).toHaveBeenCalledWith('🚀  Server is running on PORT 3333');
+        await adapter.close();
+    });
+    it('should map express controller errors through callback.throw', async () => {
+        let routeHandler;
+        const controller = {
+            handle: vitest_1.vi.fn().mockRejectedValue(new Error('failed')),
+            throw: vitest_1.vi.fn().mockReturnValue({
+                code: 422,
+                data: { message: 'mapped' },
+            }),
+        };
+        const response = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            json: vitest_1.vi.fn().mockReturnThis(),
+        };
+        expressInstance.get.mockImplementation((_url, handler) => {
+            routeHandler = handler;
+        });
+        const adapter = new express_adapter_1.default({
+            NODE_ENV: 'test',
+        });
+        adapter.on('get', '/partners', controller);
+        await routeHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, response);
+        expect(controller.throw).toHaveBeenCalledWith(expect.any(Error));
+        expect(response.status).toHaveBeenCalledWith(422);
+        expect(response.json).toHaveBeenCalledWith({ message: 'mapped' });
+    });
+    it('should default express success and error payloads when they are omitted', async () => {
+        let successRouteHandler;
+        let errorRouteHandler;
+        const successController = {
+            handle: vitest_1.vi.fn().mockResolvedValue({}),
+            throw: vitest_1.vi.fn(),
+        };
+        const errorController = {
+            handle: vitest_1.vi.fn().mockRejectedValue(new Error('failed')),
+            throw: vitest_1.vi.fn().mockReturnValue({
+                code: 418,
+            }),
+        };
+        const response = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            json: vitest_1.vi.fn().mockReturnThis(),
+        };
+        expressInstance.delete.mockImplementation((_url, handler) => {
+            successRouteHandler = handler;
+        });
+        expressInstance.put.mockImplementation((_url, handler) => {
+            errorRouteHandler = handler;
+        });
+        const adapter = new express_adapter_1.default({
+            NODE_ENV: 'test',
+        });
+        adapter.on('delete', '/partners', successController);
+        adapter.on('put', '/partners', errorController);
+        await successRouteHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, response);
+        await errorRouteHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, response);
+        expect(response.status).toHaveBeenNthCalledWith(1, 200);
+        expect(response.json).toHaveBeenNthCalledWith(1, {});
+        expect(response.status).toHaveBeenNthCalledWith(2, 418);
+        expect(response.json).toHaveBeenNthCalledWith(2, {});
+    });
+    it('should configure fastify and route requests', async () => {
+        let routeHandler;
+        const controller = {
+            handle: vitest_1.vi.fn().mockResolvedValue({
+                code: 200,
+                data: { id: '1' },
+            }),
+            throw: vitest_1.vi.fn(),
+        };
+        const reply = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            send: vitest_1.vi.fn().mockReturnThis(),
+        };
+        const consoleLog = vitest_1.vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        fastifyInstance.get.mockImplementation((_url, handler) => {
+            routeHandler = handler;
+        });
+        fastifyInstance.listen.mockImplementation((_options, callback) => {
+            callback(null, undefined);
+        });
+        const adapter = new fastify_adapter_1.default({
+            NODE_ENV: 'production',
+        });
+        expect(fastify_1.default).toHaveBeenCalledTimes(1);
+        expect(fastifyInstance.register).toHaveBeenCalledTimes(1);
+        adapter.on('get', '/partners', controller);
+        await routeHandler({
+            body: { id: '1' },
+            params: { partnerId: '1' },
+            headers: { authorization: 'token' },
+            query: { page: '1' },
+        }, reply);
+        expect(controller.handle).toHaveBeenCalledWith({
+            body: { id: '1' },
+            params: { partnerId: '1' },
+            headers: { authorization: 'token' },
+            query: { page: '1' },
+        });
+        expect(reply.status).toHaveBeenCalledWith(200);
+        expect(reply.send).toHaveBeenCalledWith({ id: '1' });
+        await adapter.listen(3333);
+        expect(fastifyInstance.ready).toHaveBeenCalledTimes(1);
+        expect(consoleLog).toHaveBeenCalledWith('🚀  Server is running on PORT 3333');
+        await adapter.close();
+        expect(fastifyInstance.close).toHaveBeenCalledTimes(1);
+    });
+    it('should map fastify controller errors and handle listen failures', async () => {
+        let routeHandler;
+        const controller = {
+            handle: vitest_1.vi.fn().mockRejectedValue(new Error('failed')),
+            throw: vitest_1.vi.fn().mockReturnValue({
+                code: 400,
+                data: { message: 'mapped' },
+            }),
+        };
+        const reply = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            send: vitest_1.vi.fn().mockReturnThis(),
+        };
+        const consoleError = vitest_1.vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        const exitSpy = vitest_1.vi
+            .spyOn(process, 'exit')
+            .mockImplementation((() => undefined));
+        fastifyInstance.post.mockImplementation((_url, handler) => {
+            routeHandler = handler;
+        });
+        fastifyInstance.listen.mockImplementation((_options, callback) => {
+            callback(new Error('listen failed'), undefined);
+        });
+        const adapter = new fastify_adapter_1.default({
+            NODE_ENV: 'test',
+        });
+        adapter.on('post', '/partners', controller);
+        await routeHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, reply);
+        expect(controller.throw).toHaveBeenCalledWith(expect.any(Error));
+        expect(reply.status).toHaveBeenCalledWith(400);
+        expect(reply.send).toHaveBeenCalledWith({ message: 'mapped' });
+        await adapter.listen(3333);
+        expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
+        expect(exitSpy).toHaveBeenCalledTimes(1);
+    });
+    it('should default fastify success and error payloads when they are omitted', async () => {
+        let successRouteHandler;
+        let errorRouteHandler;
+        const successController = {
+            handle: vitest_1.vi.fn().mockResolvedValue({}),
+            throw: vitest_1.vi.fn(),
+        };
+        const errorController = {
+            handle: vitest_1.vi.fn().mockRejectedValue(new Error('failed')),
+            throw: vitest_1.vi.fn().mockReturnValue({}),
+        };
+        const reply = {
+            status: vitest_1.vi.fn().mockReturnThis(),
+            send: vitest_1.vi.fn().mockReturnThis(),
+        };
+        fastifyInstance.delete.mockImplementation((_url, handler) => {
+            successRouteHandler = handler;
+        });
+        fastifyInstance.put.mockImplementation((_url, handler) => {
+            errorRouteHandler = handler;
+        });
+        const adapter = new fastify_adapter_1.default({
+            NODE_ENV: 'test',
+        });
+        adapter.on('delete', '/partners', successController);
+        adapter.on('put', '/partners', errorController);
+        await successRouteHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, reply);
+        await errorRouteHandler({
+            body: {},
+            params: {},
+            headers: {},
+            query: {},
+        }, reply);
+        expect(reply.status).toHaveBeenNthCalledWith(1, 200);
+        expect(reply.send).toHaveBeenNthCalledWith(1, {});
+        expect(reply.status).toHaveBeenNthCalledWith(2, 200);
+        expect(reply.send).toHaveBeenNthCalledWith(2, {});
+    });
+});

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

@@ -142,4 +142,47 @@ 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-clients.spec.d.ts

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

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

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fakeNodeCache = {
+    del: vitest_1.vi.fn(),
+    flushAll: vitest_1.vi.fn(),
+    get: vitest_1.vi.fn(),
+    getStats: vitest_1.vi.fn(),
+    keys: vitest_1.vi.fn(),
+    set: vitest_1.vi.fn(),
+};
+const redisState = {
+    instance: null,
+};
+vitest_1.vi.mock('node-cache', () => ({
+    default: vitest_1.vi.fn(() => fakeNodeCache),
+}));
+vitest_1.vi.mock('ioredis', () => ({
+    default: vitest_1.vi.fn((connection) => {
+        redisState.instance = {
+            connection,
+            del: vitest_1.vi.fn().mockResolvedValue(undefined),
+            flushdb: vitest_1.vi.fn().mockResolvedValue(undefined),
+            get: vitest_1.vi.fn().mockResolvedValue(null),
+            keys: vitest_1.vi.fn().mockResolvedValue([]),
+            pipeline: vitest_1.vi.fn(() => {
+                const pipeline = {
+                    del: vitest_1.vi.fn().mockReturnThis(),
+                    exec: vitest_1.vi.fn().mockResolvedValue(undefined),
+                };
+                return pipeline;
+            }),
+            quit: vitest_1.vi.fn().mockResolvedValue(undefined),
+            set: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        return redisState.instance;
+    }),
+}));
+const node_cache_1 = require("./clients/node-cache");
+const redis_1 = require("./clients/redis");
+(0, vitest_1.describe)('Cache clients', () => {
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.resetModules();
+    });
+    (0, vitest_1.it)('should start, query and manage the in-memory node cache client', async () => {
+        const client = new node_cache_1.NodeCache();
+        fakeNodeCache.get.mockResolvedValueOnce(JSON.stringify({ id: '1' }));
+        fakeNodeCache.get.mockResolvedValueOnce(undefined);
+        fakeNodeCache.getStats.mockReturnValue({ vsize: 1, ksize: 1 });
+        fakeNodeCache.keys.mockReturnValue(['cache:1', 'cache:2', 'other']);
+        await client.start();
+        await (0, vitest_1.expect)(client.get('cache:1')).resolves.toEqual({ id: '1' });
+        await (0, vitest_1.expect)(client.get('cache:2')).resolves.toBeNull();
+        await (0, vitest_1.expect)(client.set('cache:1', '{"id":"1"}', 10)).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.getKeys()).resolves.toEqual([
+            'cache:1',
+            'cache:2',
+            'other',
+        ]);
+        await (0, vitest_1.expect)(client.getKeys('^cache')).resolves.toEqual([
+            'cache:1',
+            'cache:2',
+        ]);
+        await (0, vitest_1.expect)(client.del('cache:1')).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.delBatch(['cache:1', 'cache:2'])).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.flush()).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.close()).resolves.toBeUndefined();
+        (0, vitest_1.expect)(fakeNodeCache.set).toHaveBeenCalledWith('cache:1', '{"id":"1"}', 10);
+        (0, vitest_1.expect)(fakeNodeCache.del).toHaveBeenNthCalledWith(1, 'cache:1');
+        (0, vitest_1.expect)(fakeNodeCache.del).toHaveBeenNthCalledWith(2, 'cache:1');
+        (0, vitest_1.expect)(fakeNodeCache.del).toHaveBeenNthCalledWith(3, 'cache:2');
+        (0, vitest_1.expect)(fakeNodeCache.flushAll).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)('should skip writes when the in-memory cache is full', async () => {
+        const client = new node_cache_1.NodeCache();
+        fakeNodeCache.getStats.mockReturnValue({
+            vsize: 50000000,
+            ksize: 0,
+        });
+        await client.start();
+        await client.set('cache:1', '{"id":"1"}', 10);
+        (0, vitest_1.expect)(fakeNodeCache.set).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should start the default in-memory cache on import', async () => {
+        vitest_1.vi.resetModules();
+        const { NodeCache: DynamicNodeCache } = await Promise.resolve().then(() => __importStar(require('./clients/node-cache')));
+        const startSpy = vitest_1.vi
+            .spyOn(DynamicNodeCache.prototype, 'start')
+            .mockResolvedValue(undefined);
+        await Promise.resolve().then(() => __importStar(require('./cache-in-memory')));
+        await Promise.resolve();
+        (0, vitest_1.expect)(startSpy).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)('should operate the Redis client through time-bounded calls', async () => {
+        vitest_1.vi.useFakeTimers();
+        const client = new redis_1.Redis({
+            host: 'localhost',
+            timeout: 1,
+        });
+        await client.start();
+        redisState.instance.get.mockResolvedValueOnce(JSON.stringify({ id: '1' }));
+        redisState.instance.get.mockResolvedValueOnce(null);
+        await (0, vitest_1.expect)(client.get('cache:1')).resolves.toEqual({ id: '1' });
+        await (0, vitest_1.expect)(client.get('cache:2')).resolves.toBeNull();
+        await (0, vitest_1.expect)(client.set('cache:1', '{"id":"1"}', 10)).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.set('cache:2', '{"id":"2"}')).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.del('cache:1')).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.getKeys('cache:*')).resolves.toEqual([]);
+        await (0, vitest_1.expect)(client.flush()).resolves.toBeUndefined();
+        await (0, vitest_1.expect)(client.close()).resolves.toBeUndefined();
+        (0, vitest_1.expect)(redisState.instance.set).toHaveBeenNthCalledWith(1, 'cache:1', '{"id":"1"}', 'EX', 10);
+        (0, vitest_1.expect)(redisState.instance.set).toHaveBeenNthCalledWith(2, 'cache:2', '{"id":"2"}');
+        (0, vitest_1.expect)(redisState.instance.del).toHaveBeenCalledWith('cache:1');
+        (0, vitest_1.expect)(redisState.instance.keys).toHaveBeenCalledWith('cache:*');
+        (0, vitest_1.expect)(redisState.instance.flushdb).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(redisState.instance.quit).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)('should delete Redis keys in batch and fallback to timeout when needed', async () => {
+        vitest_1.vi.useFakeTimers();
+        const client = new redis_1.Redis({
+            host: 'localhost',
+            timeout: 1,
+        });
+        await client.start();
+        const pendingGet = new Promise(() => undefined);
+        redisState.instance.get.mockReturnValueOnce(pendingGet);
+        const getPromise = client.get('cache:1');
+        await vitest_1.vi.advanceTimersByTimeAsync(1000);
+        await (0, vitest_1.expect)(getPromise).resolves.toBeNull();
+        await client.delBatch(['cache:1', 'cache:2']);
+        const pipeline = redisState.instance.pipeline.mock.results[0].value;
+        (0, vitest_1.expect)(pipeline.del).toHaveBeenNthCalledWith(1, 'cache:1');
+        (0, vitest_1.expect)(pipeline.del).toHaveBeenNthCalledWith(2, 'cache:2');
+        (0, vitest_1.expect)(pipeline.exec).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,7 +1,12 @@
 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,9 +2,15 @@
 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,15 +1,32 @@
 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,17 +4,27 @@ 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;
@@ -22,29 +32,37 @@ 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(this.del));
+        await Promise.all(keyCache.map(key => this.del(key)));
     }
+    /** Lista chaves; se pattern existir, filtra via RegExp. */
     async getKeys(pattern) {
         const keys = this.client.keys();
         if (!pattern)
             return keys;
-        return keys.filter(new RegExp(pattern).test);
+        const regex = new RegExp(pattern);
+        return keys.filter(key => regex.test(key));
     }
+    /** 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();