@seidor-cloud-produtos/orbit-backend-lib 2.0.109 → 2.0.111

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const create_password_factory_1 = tslib_1.__importDefault(require("../factories/create-password-factory"));
+const random_password_temporary_factory_1 = tslib_1.__importDefault(require("../factories/random-password-temporary-factory"));
+const invalid_password_algorithm_error_1 = tslib_1.__importDefault(require("../errors/invalid-password-algorithm-error"));
+const invalid_password_length_error_1 = tslib_1.__importDefault(require("../errors/invalid-password-length-error"));
+const password_1 = tslib_1.__importStar(require("./password"));
+const pbkdf2_password_1 = tslib_1.__importDefault(require("./pbkdf2-password"));
+const sha1_password_1 = tslib_1.__importDefault(require("./sha1-password"));
+class TestPassword extends password_1.default {
+    constructor() {
+        super({ algorithm: password_1.PasswordAlgorithm.SHA1, isTemporary: true });
+    }
+    static validate(value) {
+        return this.isValid(value);
+    }
+    isEqual() {
+        return false;
+    }
+}
+describe('Password value objects and factories', () => {
+    it('should validate the minimum password length in the base class', () => {
+        expect(TestPassword.validate('1234567')).toBe(false);
+        expect(TestPassword.validate('12345678')).toBe(true);
+    });
+    it('should create and restore SHA1 passwords', () => {
+        const password = sha1_password_1.default.create('12345678');
+        const restored = sha1_password_1.default.restore(password.value, null);
+        expect(password.algorithm).toBe(password_1.PasswordAlgorithm.SHA1);
+        expect(password.isTemporary).toBe(true);
+        expect(password.notEncryptedValue).toBe('12345678');
+        expect(password.isEqual('12345678')).toBe(true);
+        expect(password.isEqual('other')).toBe(false);
+        expect(restored.isEqual('12345678')).toBe(true);
+    });
+    it('should reject invalid SHA1 passwords', () => {
+        expect(() => sha1_password_1.default.create('short')).toThrow(invalid_password_length_error_1.default);
+    });
+    it('should create and restore PBKDF2 passwords', () => {
+        const password = pbkdf2_password_1.default.create('12345678');
+        const restored = pbkdf2_password_1.default.restore(password.value, password.salt);
+        expect(password.algorithm).toBe(password_1.PasswordAlgorithm.PBKDF2);
+        expect(password.isTemporary).toBe(false);
+        expect(password.notEncryptedValue).toBe('12345678');
+        expect(password.salt).toBeTruthy();
+        expect(password.value).toHaveLength(128);
+        expect(password.isEqual('12345678')).toBe(true);
+        expect(password.isEqual('other')).toBe(false);
+        expect(restored.isEqual('12345678')).toBe(true);
+    });
+    it('should reject invalid PBKDF2 passwords', () => {
+        expect(() => pbkdf2_password_1.default.create('short')).toThrow(invalid_password_length_error_1.default);
+    });
+    it('should create valid temporary passwords', () => {
+        const generatedPassword = random_password_temporary_factory_1.default.create();
+        expect(generatedPassword).toHaveLength(8);
+        expect(random_password_temporary_factory_1.default.isValid(generatedPassword)).toBe(true);
+        expect(random_password_temporary_factory_1.default.create('fixed-value')).toBe('fixed-value');
+        expect(random_password_temporary_factory_1.default.isValid('short')).toBe(false);
+        expect(random_password_temporary_factory_1.default.isValid('abcdefgh')).toBe(false);
+        expect(random_password_temporary_factory_1.default.isValid('Abcdefgh')).toBe(false);
+        expect(random_password_temporary_factory_1.default.isValid('!bcdefgh')).toBe(false);
+    });
+    it('should create passwords using the factory', () => {
+        const randomPassword = create_password_factory_1.default.create();
+        const sha1Password = create_password_factory_1.default.create({
+            value: 'sha1-value',
+            algorithm: password_1.PasswordAlgorithm.SHA1,
+            salt: null,
+        });
+        const pbkdf2Password = create_password_factory_1.default.create({
+            value: 'pbkdf2-value',
+            algorithm: password_1.PasswordAlgorithm.PBKDF2,
+            salt: 'salt',
+        });
+        expect(randomPassword).toBeInstanceOf(sha1_password_1.default);
+        expect(sha1Password).toBeInstanceOf(sha1_password_1.default);
+        expect(pbkdf2Password).toBeInstanceOf(pbkdf2_password_1.default);
+        expect(sha1Password.value).toBe('sha1-value');
+        expect(pbkdf2Password.salt).toBe('salt');
+    });
+    it('should throw when the factory receives an invalid algorithm', () => {
+        expect(() => create_password_factory_1.default.create({
+            value: 'value',
+            algorithm: 'other',
+            salt: null,
+        })).toThrow(invalid_password_algorithm_error_1.default);
+    });
+});

package/dist/clean-arch/infra/adapters/http-adapters.spec.d.ts

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

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/clients/node-cache.js

@@ -44,14 +44,15 @@ class NodeCache extends client_1.CacheClient {
     }
     /** 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() {