@flusys/nestjs-shared 6.0.2 → 6.1.0

package/cjs/classes/handle-custome-db.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _handlecustomedb = require("./handle-custome-db");
+const mockGetTypeOrmConfig = jest.fn();
+jest.mock('@flusys/nestjs-core', ()=>({
+        envConfig: {
+            getTypeOrmConfig: (...args)=>mockGetTypeOrmConfig(...args)
+        }
+    }));
+describe('handle-custome-db', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+    });
+    describe('getJsonColumnType', ()=>{
+        it('should return jsonb for postgres', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'postgres'
+            });
+            expect((0, _handlecustomedb.getJsonColumnType)()).toBe('jsonb');
+        });
+        it('should return json for mysql', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'mysql'
+            });
+            expect((0, _handlecustomedb.getJsonColumnType)()).toBe('json');
+        });
+        it('should return simple-json for mariadb', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'mariadb'
+            });
+            expect((0, _handlecustomedb.getJsonColumnType)()).toBe('simple-json');
+        });
+        it('should return simple-json for sqlite', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'sqlite'
+            });
+            expect((0, _handlecustomedb.getJsonColumnType)()).toBe('simple-json');
+        });
+    });
+    describe('getCastIntType', ()=>{
+        it('should return INTEGER for postgres', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'postgres'
+            });
+            expect((0, _handlecustomedb.getCastIntType)()).toBe('INTEGER');
+        });
+        it('should return UNSIGNED for mysql', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'mysql'
+            });
+            expect((0, _handlecustomedb.getCastIntType)()).toBe('UNSIGNED');
+        });
+        it('should return UNSIGNED for mariadb', ()=>{
+            mockGetTypeOrmConfig.mockReturnValue({
+                type: 'mariadb'
+            });
+            expect((0, _handlecustomedb.getCastIntType)()).toBe('UNSIGNED');
+        });
+    });
+    describe('buildQuery', ()=>{
+        it('should leave the sql untouched for mysql', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('SELECT * FROM t WHERE id = ?', 'mysql')).toBe('SELECT * FROM t WHERE id = ?');
+        });
+        it('should leave the sql untouched for mariadb', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('SELECT * FROM t WHERE id = ?', 'mariadb')).toBe('SELECT * FROM t WHERE id = ?');
+        });
+        it('should convert a single ? placeholder to $1 for postgres', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('SELECT * FROM t WHERE id = ?', 'postgres')).toBe('SELECT * FROM t WHERE id = $1');
+        });
+        it('should convert multiple ? placeholders in order for postgres', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('WHERE a = ? AND b = ? AND c = ?', 'postgres')).toBe('WHERE a = $1 AND b = $2 AND c = $3');
+        });
+        it('should return the sql unchanged when there are no placeholders', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('SELECT 1', 'postgres')).toBe('SELECT 1');
+        });
+        it('should handle an empty sql string', ()=>{
+            expect((0, _handlecustomedb.buildQuery)('', 'postgres')).toBe('');
+        });
+    });
+});

package/cjs/classes/hybrid-cache.class.spec.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _hybridcacheclass = require("./hybrid-cache.class");
+const mockTryGetValue = jest.fn();
+const mockGetRedisUrl = jest.fn();
+jest.mock('@flusys/nestjs-core/config', ()=>({
+        envConfig: {
+            tryGetValue: (...args)=>mockTryGetValue(...args),
+            getRedisUrl: (...args)=>mockGetRedisUrl(...args)
+        }
+    }));
+const mockKeyvGet = jest.fn();
+const mockKeyvSet = jest.fn();
+const mockKeyvDelete = jest.fn();
+const mockKeyvClear = jest.fn();
+const KeyvCtor = jest.fn().mockImplementation(()=>({
+        get: mockKeyvGet,
+        set: mockKeyvSet,
+        delete: mockKeyvDelete,
+        clear: mockKeyvClear
+    }));
+jest.mock('keyv', ()=>({
+        __esModule: true,
+        default: KeyvCtor
+    }));
+jest.mock('@keyv/redis', ()=>({
+        __esModule: true,
+        default: jest.fn().mockImplementation(()=>({}))
+    }));
+jest.mock('cacheable', ()=>({
+        CacheableMemory: jest.fn().mockImplementation(()=>({}))
+    }));
+describe('HybridCache', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockGetRedisUrl.mockReturnValue('redis://localhost:6379');
+    });
+    describe('construction', ()=>{
+        it('should default to memory-only cache when USE_CACHE_LABEL is unset', ()=>{
+            mockTryGetValue.mockReturnValue('');
+            new _hybridcacheclass.HybridCache();
+            expect(KeyvCtor).toHaveBeenCalledTimes(1);
+        });
+        it('should create only a memory store for "memory" mode', ()=>{
+            mockTryGetValue.mockReturnValue('memory');
+            new _hybridcacheclass.HybridCache();
+            expect(KeyvCtor).toHaveBeenCalledTimes(1);
+        });
+        it('should create only a redis store for "redis" mode', async ()=>{
+            mockTryGetValue.mockReturnValue('redis');
+            const cache = new _hybridcacheclass.HybridCache();
+            mockKeyvGet.mockResolvedValue('redis-value');
+            const result = await cache.get('key');
+            expect(KeyvCtor).toHaveBeenCalledTimes(1);
+            expect(result).toBe('redis-value');
+        });
+        it('should create both stores for "hybrid" mode', ()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            new _hybridcacheclass.HybridCache();
+            expect(KeyvCtor).toHaveBeenCalledTimes(2);
+        });
+        it('should pass custom ttl and size through to the memory store options', ()=>{
+            mockTryGetValue.mockReturnValue('memory');
+            const { CacheableMemory } = require('cacheable');
+            new _hybridcacheclass.HybridCache(30_000, 100);
+            expect(CacheableMemory).toHaveBeenCalledWith({
+                ttl: 30_000,
+                lruSize: 100
+            });
+        });
+    });
+    describe('get (hybrid mode)', ()=>{
+        let cache;
+        beforeEach(()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            cache = new _hybridcacheclass.HybridCache();
+        });
+        it('should return the memory value without touching redis when present', async ()=>{
+            mockKeyvGet.mockResolvedValueOnce('memory-value');
+            const result = await cache.get('key');
+            expect(result).toBe('memory-value');
+            expect(mockKeyvGet).toHaveBeenCalledTimes(1);
+        });
+        it('should fall back to redis and backfill memory on L1 miss', async ()=>{
+            mockKeyvGet.mockResolvedValueOnce(undefined).mockResolvedValueOnce('redis-value');
+            const result = await cache.get('key');
+            expect(result).toBe('redis-value');
+            expect(mockKeyvSet).toHaveBeenCalledWith('key', 'redis-value');
+        });
+        it('should return undefined without backfilling when redis also misses', async ()=>{
+            mockKeyvGet.mockResolvedValue(undefined);
+            const result = await cache.get('key');
+            expect(result).toBeUndefined();
+            expect(mockKeyvSet).not.toHaveBeenCalled();
+        });
+        it('should treat falsy-but-defined values (0, "", false) as cache hits', async ()=>{
+            mockKeyvGet.mockResolvedValueOnce(0);
+            const result = await cache.get('key');
+            expect(result).toBe(0);
+        });
+    });
+    describe('get (memory-only mode)', ()=>{
+        it('should return undefined when there is no redis store to fall back to', async ()=>{
+            mockTryGetValue.mockReturnValue('memory');
+            const cache = new _hybridcacheclass.HybridCache();
+            mockKeyvGet.mockResolvedValue(undefined);
+            const result = await cache.get('key');
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('set', ()=>{
+        it('should write to both stores in hybrid mode with the given ttl', async ()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            const cache = new _hybridcacheclass.HybridCache();
+            await cache.set('key', {
+                a: 1
+            }, 5000);
+            expect(mockKeyvSet).toHaveBeenNthCalledWith(1, 'key', {
+                a: 1
+            }, 5000);
+            expect(mockKeyvSet).toHaveBeenNthCalledWith(2, 'key', {
+                a: 1
+            }, 5000);
+        });
+        it('should write only to memory when redis is not configured', async ()=>{
+            mockTryGetValue.mockReturnValue('memory');
+            const cache = new _hybridcacheclass.HybridCache();
+            await cache.set('key', 'value');
+            expect(mockKeyvSet).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('del', ()=>{
+        it('should delete from both stores in hybrid mode', async ()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            const cache = new _hybridcacheclass.HybridCache();
+            await cache.del('key');
+            expect(mockKeyvDelete).toHaveBeenCalledTimes(2);
+        });
+        it('should be a no-op safe call when no stores are configured', async ()=>{
+            mockTryGetValue.mockReturnValue('unknown-mode');
+            const cache = new _hybridcacheclass.HybridCache();
+            await expect(cache.del('key')).resolves.toBeUndefined();
+            expect(mockKeyvDelete).not.toHaveBeenCalled();
+        });
+    });
+    describe('reset / resetL2', ()=>{
+        it('reset should clear only the memory store', async ()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            const cache = new _hybridcacheclass.HybridCache();
+            await cache.reset();
+            expect(mockKeyvClear).toHaveBeenCalledTimes(1);
+        });
+        it('resetL2 should clear only the redis store', async ()=>{
+            mockTryGetValue.mockReturnValue('hybrid');
+            const cache = new _hybridcacheclass.HybridCache();
+            await cache.resetL2();
+            expect(mockKeyvClear).toHaveBeenCalledTimes(1);
+        });
+        it('reset should be a no-op when memory is not configured', async ()=>{
+            mockTryGetValue.mockReturnValue('redis');
+            const cache = new _hybridcacheclass.HybridCache();
+            await expect(cache.reset()).resolves.toBeUndefined();
+            expect(mockKeyvClear).not.toHaveBeenCalled();
+        });
+    });
+});

package/cjs/classes/winston.logger.class.spec.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const mockExistsSync = jest.fn();
+const mockMkdirSync = jest.fn();
+jest.mock('fs', ()=>({
+        existsSync: (...args)=>mockExistsSync(...args),
+        mkdirSync: (...args)=>mockMkdirSync(...args)
+    }));
+const mockGetLogConfig = jest.fn();
+const mockUseTenantMode = jest.fn();
+const mockIsProduction = jest.fn();
+jest.mock('@flusys/nestjs-core/config', ()=>({
+        envConfig: {
+            getLogConfig: (...args)=>mockGetLogConfig(...args),
+            useTenantMode: (...args)=>mockUseTenantMode(...args),
+            isProduction: (...args)=>mockIsProduction(...args)
+        }
+    }));
+const { EventEmitter } = require('events');
+let FakeDailyRotateFile = class FakeDailyRotateFile extends EventEmitter {
+    constructor(options){
+        super(), _define_property(this, "options", void 0), _define_property(this, "log", jest.fn((_info, callback)=>callback?.()));
+        this.options = options;
+    }
+};
+jest.mock('winston-daily-rotate-file', ()=>({
+        __esModule: true,
+        default: FakeDailyRotateFile
+    }));
+let capturedPrintf;
+jest.mock('winston', ()=>{
+    const actual = jest.requireActual('winston');
+    // winston's `format` export exposes its sub-formatters (colorize, combine, printf, ...)
+    // as non-enumerable getters, so a plain object spread silently drops them. Delegate through
+    // the prototype chain instead and only shadow `printf` to capture the formatter callback.
+    const realPrintf = actual.format.printf;
+    const mockFormat = Object.create(actual.format);
+    Object.defineProperty(mockFormat, 'printf', {
+        value: (fn)=>{
+            capturedPrintf = fn;
+            return realPrintf(fn);
+        }
+    });
+    return {
+        ...actual,
+        format: mockFormat
+    };
+});
+describe('winston.logger.class', ()=>{
+    let consoleErrorSpy;
+    beforeEach(()=>{
+        jest.resetModules();
+        jest.clearAllMocks();
+        // FakeDailyRotateFile isn't a real winston-transport instance, so winston logs a
+        // harmless "legacy transport" deprecation warning via console.error on each createLogger call.
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(()=>undefined);
+        mockExistsSync.mockReturnValue(true);
+        mockGetLogConfig.mockReturnValue({
+            dir: 'logs',
+            level: 'debug',
+            maxSize: '20m',
+            maxFiles: '14d',
+            disableHttpLogging: false
+        });
+        mockUseTenantMode.mockReturnValue(false);
+    });
+    afterEach(()=>{
+        consoleErrorSpy.mockRestore();
+    });
+    it('should create the log directory when it does not exist', ()=>{
+        mockExistsSync.mockReturnValue(false);
+        mockIsProduction.mockReturnValue(false);
+        require('./winston.logger.class');
+        expect(mockMkdirSync).toHaveBeenCalledWith('logs', {
+            recursive: true
+        });
+    });
+    it('should not attempt to create the log directory when it already exists', ()=>{
+        mockExistsSync.mockReturnValue(true);
+        mockIsProduction.mockReturnValue(false);
+        require('./winston.logger.class');
+        expect(mockMkdirSync).not.toHaveBeenCalledWith('logs', {
+            recursive: true
+        });
+    });
+    it('should export a dev (console-based) instance when not in production', ()=>{
+        mockIsProduction.mockReturnValue(false);
+        const { instance } = require('./winston.logger.class');
+        expect(instance).toBeDefined();
+        expect(typeof instance.log).toBe('function');
+    });
+    it('should export a prod (file-rotation-based) instance when in production', ()=>{
+        mockIsProduction.mockReturnValue(true);
+        const { instance } = require('./winston.logger.class');
+        expect(instance).toBeDefined();
+        expect(typeof instance.log).toBe('function');
+    });
+    describe('createModuleLogger', ()=>{
+        it('should return the shared dev logger instance in non-production mode', ()=>{
+            mockIsProduction.mockReturnValue(false);
+            const { createModuleLogger, instance } = require('./winston.logger.class');
+            expect(createModuleLogger('auth')).toBe(instance);
+            expect(createModuleLogger('iam')).toBe(instance);
+        });
+        it('should create a distinct, cached logger per module in production mode', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            const { createModuleLogger } = require('./winston.logger.class');
+            const authLogger1 = createModuleLogger('auth');
+            const authLogger2 = createModuleLogger('auth');
+            const iamLogger = createModuleLogger('iam');
+            expect(authLogger1).toBe(authLogger2);
+            expect(authLogger1).not.toBe(iamLogger);
+        });
+        it('should create the module-specific log directory on first use in production mode', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockExistsSync.mockImplementation((p)=>p === 'logs');
+            const { createModuleLogger } = require('./winston.logger.class');
+            createModuleLogger('storage');
+            expect(mockMkdirSync).toHaveBeenCalledWith(expect.stringContaining('storage'), {
+                recursive: true
+            });
+        });
+        it('should not recreate the module directory or transport on subsequent calls', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockExistsSync.mockReturnValue(true);
+            const { createModuleLogger } = require('./winston.logger.class');
+            createModuleLogger('storage');
+            const mkdirCallsAfterFirst = mockMkdirSync.mock.calls.length;
+            createModuleLogger('storage');
+            expect(mockMkdirSync.mock.calls.length).toBe(mkdirCallsAfterFirst);
+        });
+    });
+    describe('structuredFormat (captured printf callback)', ()=>{
+        beforeEach(()=>{
+            mockIsProduction.mockReturnValue(true);
+            capturedPrintf = undefined;
+            require('./winston.logger.class');
+        });
+        it('should capture the printf formatter', ()=>{
+            expect(capturedPrintf).toBeInstanceOf(Function);
+        });
+        it('should default the request id when absent and map known levels', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'error',
+                message: 'boom'
+            });
+            expect(out).toContain('[no-request-id]');
+            expect(out).toContain('Error');
+        });
+        it('should use the provided requestId and title-case unknown levels', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'silly',
+                message: 'x',
+                requestId: 'req-1'
+            });
+            expect(out).toContain('[req-1]');
+            expect(out).toContain('Silly');
+        });
+        it('should render context, endpoint, status, duration and user/tenant/company parts', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'info',
+                message: 'handled',
+                context: 'AuthService',
+                method: 'POST',
+                path: '/login',
+                statusCode: 200,
+                duration: '12ms',
+                userId: 'u1',
+                tenantId: 't1',
+                companyId: 'c1'
+            });
+            expect(out).toContain('Context: AuthService');
+            expect(out).toContain('Endpoint: POST /login');
+            expect(out).toContain('Status: 200');
+            expect(out).toContain('Duration: 12ms');
+            expect(out).toContain('UserId: u1');
+            expect(out).toContain('TenantId: t1');
+            expect(out).toContain('CompanyId: c1');
+            expect(out).toContain('handled');
+        });
+        it('should fall back to `url` for the endpoint line when `path` is absent', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'info',
+                message: 'm',
+                method: 'GET',
+                url: '/legacy'
+            });
+            expect(out).toContain('Endpoint: GET /legacy');
+        });
+        it('should omit the endpoint line entirely when method has no path or url', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'info',
+                message: 'm',
+                method: 'GET'
+            });
+            expect(out).not.toContain('Endpoint:');
+        });
+        it('should append remaining metadata as JSON, excluding the `splat` key', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'info',
+                message: 'm',
+                splat: [
+                    'ignored'
+                ],
+                orderId: 'o1',
+                amount: 50
+            });
+            expect(out).toContain('Metadata: {"orderId":"o1","amount":50}');
+            expect(out).not.toContain('ignored');
+        });
+        it('should omit the Metadata line when no extra metadata remains', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'info',
+                message: 'm',
+                splat: []
+            });
+            expect(out).not.toContain('Metadata:');
+        });
+        it('should append the stack trace when present', ()=>{
+            const out = capturedPrintf({
+                timestamp: 'T',
+                level: 'error',
+                message: 'crashed',
+                stack: 'Error: crashed\n    at foo.ts:1:1'
+            });
+            expect(out).toContain('Stack: Error: crashed');
+        });
+    });
+    describe('TenantAwareTransport routing', ()=>{
+        it('should route to the default transport when tenant mode is disabled', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockUseTenantMode.mockReturnValue(false);
+            const { instance } = require('./winston.logger.class');
+            const tenantAwareTransport = instance.transports[0];
+            const defaultTransport = tenantAwareTransport.defaultTransport;
+            const logSpy = jest.spyOn(defaultTransport, 'log');
+            const cb = jest.fn();
+            tenantAwareTransport.log({
+                level: 'info',
+                message: 'x',
+                tenantId: 't1'
+            }, cb);
+            expect(logSpy).toHaveBeenCalled();
+        });
+        it('should route to the default transport when tenant mode is enabled but no tenantId is present', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockUseTenantMode.mockReturnValue(true);
+            const { instance } = require('./winston.logger.class');
+            const tenantAwareTransport = instance.transports[0];
+            const defaultTransport = tenantAwareTransport.defaultTransport;
+            const logSpy = jest.spyOn(defaultTransport, 'log');
+            const cb = jest.fn();
+            tenantAwareTransport.log({
+                level: 'info',
+                message: 'x'
+            }, cb);
+            expect(logSpy).toHaveBeenCalled();
+        });
+        it('should route to a tenant-specific transport when tenant mode is enabled and tenantId is present', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockUseTenantMode.mockReturnValue(true);
+            mockExistsSync.mockReturnValue(true);
+            const { instance } = require('./winston.logger.class');
+            const tenantAwareTransport = instance.transports[0];
+            const defaultTransport = tenantAwareTransport.defaultTransport;
+            const defaultLogSpy = jest.spyOn(defaultTransport, 'log');
+            const cb = jest.fn();
+            tenantAwareTransport.log({
+                level: 'info',
+                message: 'x',
+                tenantId: 'tenant-a'
+            }, cb);
+            expect(defaultLogSpy).not.toHaveBeenCalled();
+        });
+        it('should read tenantId from nested `metadata.tenantId` when top-level tenantId is absent', ()=>{
+            mockIsProduction.mockReturnValue(true);
+            mockUseTenantMode.mockReturnValue(true);
+            mockExistsSync.mockReturnValue(true);
+            const { instance } = require('./winston.logger.class');
+            const tenantAwareTransport = instance.transports[0];
+            const defaultTransport = tenantAwareTransport.defaultTransport;
+            const defaultLogSpy = jest.spyOn(defaultTransport, 'log');
+            const cb = jest.fn();
+            tenantAwareTransport.log({
+                level: 'info',
+                message: 'x',
+                metadata: {
+                    tenantId: 'tenant-b'
+                }
+            }, cb);
+            expect(defaultLogSpy).not.toHaveBeenCalled();
+        });
+        it('should re-emit "logged" so winston can track transport completion', (done)=>{
+            mockIsProduction.mockReturnValue(true);
+            mockUseTenantMode.mockReturnValue(false);
+            const { instance } = require('./winston.logger.class');
+            const tenantAwareTransport = instance.transports[0];
+            tenantAwareTransport.once('logged', (info)=>{
+                expect(info.message).toBe('done-check');
+                done();
+            });
+            tenantAwareTransport.log({
+                level: 'info',
+                message: 'done-check'
+            }, jest.fn());
+        });
+    });
+});