@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/classes/event-transports/rabbitmq-transport.optional.spec.js

@@ -1,251 +0,0 @@
-const mockLoadOptionalModule = jest.fn();
-jest.mock('../../utils/optional-module.util', ()=>({
-        loadOptionalModule: (...args)=>mockLoadOptionalModule(...args)
-    }));
-import { InternalServerErrorException, Logger } from '@nestjs/common';
-import { RabbitMqTransport } from './rabbitmq-transport.optional';
-function buildEvent() {
-    return {
-        id: 'event-1',
-        name: 'storage.folder.created',
-        module: 'storage',
-        entity: 'folder',
-        action: 'created',
-        payload: {
-            ids: [
-                '1'
-            ]
-        },
-        actor: {},
-        occurredAt: '2026-01-01T00:00:00.000Z',
-        version: 1
-    };
-}
-function createChannelMock() {
-    return {
-        assertExchange: jest.fn().mockResolvedValue(undefined),
-        assertQueue: jest.fn().mockResolvedValue(undefined),
-        prefetch: jest.fn().mockResolvedValue(undefined),
-        bindQueue: jest.fn().mockResolvedValue(undefined),
-        consume: jest.fn().mockResolvedValue(undefined),
-        publish: jest.fn(),
-        ack: jest.fn(),
-        nack: jest.fn(),
-        on: jest.fn(),
-        removeAllListeners: jest.fn(),
-        close: jest.fn().mockResolvedValue(undefined)
-    };
-}
-/** A reconnect must land on a fresh channel, so every createChannel yields one */ function createAmqpMock() {
-    const channels = [];
-    const connection = {
-        createChannel: jest.fn(async ()=>{
-            const channel = createChannelMock();
-            channels.push(channel);
-            return channel;
-        }),
-        on: jest.fn(),
-        removeAllListeners: jest.fn(),
-        close: jest.fn().mockResolvedValue(undefined)
-    };
-    return {
-        channels,
-        connection,
-        connect: jest.fn().mockResolvedValue(connection),
-        get channel () {
-            return channels[channels.length - 1];
-        }
-    };
-}
-function listenerFor(target, event) {
-    const registered = target.on.mock.calls.find(([name])=>name === event);
-    if (!registered) throw new Error(`No '${event}' listener was registered`);
-    return registered[1];
-}
-describe('RabbitMqTransport', ()=>{
-    let amqp;
-    let warnSpy;
-    let errorSpy;
-    beforeEach(()=>{
-        amqp = createAmqpMock();
-        mockLoadOptionalModule.mockResolvedValue({
-            connect: amqp.connect
-        });
-        warnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        errorSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
-    });
-    afterEach(()=>{
-        warnSpy.mockRestore();
-        errorSpy.mockRestore();
-        jest.clearAllMocks();
-    });
-    it('should throw a descriptive error when amqplib is not installed', async ()=>{
-        mockLoadOptionalModule.mockRejectedValue(new Error('Cannot find module'));
-        await expect(new RabbitMqTransport().connect()).rejects.toThrow(InternalServerErrorException);
-    });
-    it('should assert a topic exchange and a durable queue on connect', async ()=>{
-        const transport = new RabbitMqTransport({
-            exchange: 'ex',
-            queue: 'svc.events'
-        });
-        await transport.connect();
-        expect(amqp.channel.assertExchange).toHaveBeenCalledWith('ex', 'topic', {
-            durable: true
-        });
-        expect(amqp.channel.assertQueue).toHaveBeenCalledWith('svc.events', {
-            durable: true
-        });
-        expect(transport.isReady()).toBe(true);
-    });
-    it('should publish with the event name as the routing key', async ()=>{
-        const transport = new RabbitMqTransport({
-            exchange: 'ex'
-        });
-        await transport.connect();
-        const event = buildEvent();
-        await transport.publish(event);
-        expect(amqp.channel.publish).toHaveBeenCalledWith('ex', 'storage.folder.created', expect.any(Buffer), expect.objectContaining({
-            messageId: 'event-1',
-            contentType: 'application/json'
-        }));
-    });
-    it('should ignore publish before connect instead of throwing', async ()=>{
-        await expect(new RabbitMqTransport().publish(buildEvent())).resolves.toBeUndefined();
-    });
-    it('should translate the ** wildcard to the AMQP # wildcard when binding', async ()=>{
-        const transport = new RabbitMqTransport({
-            exchange: 'ex',
-            queue: 'q'
-        });
-        await transport.connect();
-        await transport.bind('storage.**');
-        expect(amqp.channel.bindQueue).toHaveBeenCalledWith('q', 'ex', 'storage.#');
-    });
-    it('should start consuming only once across several binds', async ()=>{
-        const transport = new RabbitMqTransport();
-        await transport.connect();
-        await transport.bind('storage.#');
-        await transport.bind('auth.#');
-        expect(amqp.channel.consume).toHaveBeenCalledTimes(1);
-    });
-    it('should hand a consumed message to its handlers and ack it', async ()=>{
-        const transport = new RabbitMqTransport();
-        const handler = jest.fn();
-        transport.onMessage(handler);
-        await transport.connect();
-        await transport.bind('storage.#');
-        const event = buildEvent();
-        const message = {
-            content: Buffer.from(JSON.stringify(event))
-        };
-        await amqp.channel.consume.mock.calls[0][1](message);
-        expect(handler).toHaveBeenCalledWith(event);
-        expect(amqp.channel.ack).toHaveBeenCalledWith(message);
-    });
-    it('should nack a message it cannot parse', async ()=>{
-        const transport = new RabbitMqTransport();
-        await transport.connect();
-        await transport.bind('storage.#');
-        const message = {
-            content: Buffer.from('not json')
-        };
-        await amqp.channel.consume.mock.calls[0][1](message);
-        expect(amqp.channel.nack).toHaveBeenCalledWith(message, false, false);
-    });
-    it('should close the channel and the connection', async ()=>{
-        const transport = new RabbitMqTransport();
-        await transport.connect();
-        await transport.close();
-        expect(amqp.channel.close).toHaveBeenCalled();
-        expect(amqp.connection.close).toHaveBeenCalled();
-        expect(transport.isReady()).toBe(false);
-    });
-    it('should reconnect when the channel dies while the connection is still up', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        listenerFor(amqp.channels[0], 'close')();
-        expect(transport.isReady()).toBe(false);
-        await jest.advanceTimersByTimeAsync(10);
-        expect(amqp.connect).toHaveBeenCalledTimes(2);
-        expect(transport.isReady()).toBe(true);
-        jest.useRealTimers();
-    });
-    it('should close the surviving connection rather than leak it on a channel failure', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        listenerFor(amqp.channels[0], 'close')();
-        await jest.advanceTimersByTimeAsync(10);
-        expect(amqp.connection.close).toHaveBeenCalledTimes(1);
-        jest.useRealTimers();
-    });
-    it('should schedule a single reconnect when the channel and the connection both close', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        listenerFor(amqp.channels[0], 'close')();
-        listenerFor(amqp.connection, 'close')();
-        await jest.advanceTimersByTimeAsync(10);
-        expect(amqp.connect).toHaveBeenCalledTimes(2);
-        jest.useRealTimers();
-    });
-    it('should re-bind every pattern onto the new channel after a reconnect', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            exchange: 'ex',
-            queue: 'q',
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        await transport.bind('storage.**');
-        listenerFor(amqp.channels[0], 'close')();
-        await jest.advanceTimersByTimeAsync(10);
-        expect(amqp.channels[1].bindQueue).toHaveBeenCalledWith('q', 'ex', 'storage.#');
-        expect(amqp.channels[1].consume).toHaveBeenCalledTimes(1);
-        jest.useRealTimers();
-    });
-    it('should ack an in-flight delivery on the channel it arrived on', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        await transport.bind('storage.#');
-        const deliver = amqp.channels[0].consume.mock.calls[0][1];
-        listenerFor(amqp.channels[0], 'close')();
-        await jest.advanceTimersByTimeAsync(10);
-        await deliver({
-            content: Buffer.from(JSON.stringify(buildEvent()))
-        });
-        expect(amqp.channels[0].ack).toHaveBeenCalled();
-        expect(amqp.channels[1].ack).not.toHaveBeenCalled();
-        jest.useRealTimers();
-    });
-    it('should let a later bind retry consuming after the broker rejects consume', async ()=>{
-        const transport = new RabbitMqTransport();
-        await transport.connect();
-        amqp.channel.consume.mockRejectedValueOnce(new Error('CHANNEL_ERROR'));
-        await expect(transport.bind('storage.#')).rejects.toThrow('CHANNEL_ERROR');
-        await transport.bind('auth.#');
-        expect(amqp.channel.consume).toHaveBeenCalledTimes(2);
-    });
-    it('should stop reconnecting once it has been closed', async ()=>{
-        jest.useFakeTimers();
-        const transport = new RabbitMqTransport({
-            reconnectDelay: 10
-        });
-        await transport.connect();
-        await transport.close();
-        listenerFor(amqp.channels[0], 'close')();
-        await jest.advanceTimersByTimeAsync(50);
-        expect(amqp.connect).toHaveBeenCalledTimes(1);
-        jest.useRealTimers();
-    });
-});

package/fesm/classes/handle-custome-db.js

@@ -1,19 +0,0 @@
-import { envConfig } from '@flusys/nestjs-core';
-export function getJsonColumnType() {
-    const driver = envConfig.getTypeOrmConfig().type;
-    if (driver === 'postgres') return 'jsonb';
-    if (driver === 'mysql') return 'json';
-    return 'simple-json';
-}
-export function getCastIntType() {
-    const driver = envConfig.getTypeOrmConfig().type;
-    return driver === 'postgres' ? 'INTEGER' : 'UNSIGNED';
-}
-/**
- * Converts MySQL-style `?` placeholders to PostgreSQL `$1, $2, ...` placeholders.
- * No-op for MySQL/MariaDB.
- */ export function buildQuery(sql, dbType) {
-    if (dbType !== 'postgres') return sql;
-    let index = 0;
-    return sql.replace(/\?/g, ()=>`$${++index}`);
-}

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

@@ -1,78 +0,0 @@
-const mockGetTypeOrmConfig = jest.fn();
-jest.mock('@flusys/nestjs-core', ()=>({
-        envConfig: {
-            getTypeOrmConfig: (...args)=>mockGetTypeOrmConfig(...args)
-        }
-    }));
-import { getJsonColumnType, getCastIntType, buildQuery } from './handle-custome-db';
-describe('handle-custome-db', ()=>{
-    beforeEach(()=>{
-        jest.clearAllMocks();
-    });
-    describe('getJsonColumnType', ()=>{
-        it('should return jsonb for postgres', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'postgres'
-            });
-            expect(getJsonColumnType()).toBe('jsonb');
-        });
-        it('should return json for mysql', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'mysql'
-            });
-            expect(getJsonColumnType()).toBe('json');
-        });
-        it('should return simple-json for mariadb', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'mariadb'
-            });
-            expect(getJsonColumnType()).toBe('simple-json');
-        });
-        it('should return simple-json for sqlite', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'sqlite'
-            });
-            expect(getJsonColumnType()).toBe('simple-json');
-        });
-    });
-    describe('getCastIntType', ()=>{
-        it('should return INTEGER for postgres', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'postgres'
-            });
-            expect(getCastIntType()).toBe('INTEGER');
-        });
-        it('should return UNSIGNED for mysql', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'mysql'
-            });
-            expect(getCastIntType()).toBe('UNSIGNED');
-        });
-        it('should return UNSIGNED for mariadb', ()=>{
-            mockGetTypeOrmConfig.mockReturnValue({
-                type: 'mariadb'
-            });
-            expect(getCastIntType()).toBe('UNSIGNED');
-        });
-    });
-    describe('buildQuery', ()=>{
-        it('should leave the sql untouched for mysql', ()=>{
-            expect(buildQuery('SELECT * FROM t WHERE id = ?', 'mysql')).toBe('SELECT * FROM t WHERE id = ?');
-        });
-        it('should leave the sql untouched for mariadb', ()=>{
-            expect(buildQuery('SELECT * FROM t WHERE id = ?', 'mariadb')).toBe('SELECT * FROM t WHERE id = ?');
-        });
-        it('should convert a single ? placeholder to $1 for postgres', ()=>{
-            expect(buildQuery('SELECT * FROM t WHERE id = ?', 'postgres')).toBe('SELECT * FROM t WHERE id = $1');
-        });
-        it('should convert multiple ? placeholders in order for postgres', ()=>{
-            expect(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(buildQuery('SELECT 1', 'postgres')).toBe('SELECT 1');
-        });
-        it('should handle an empty sql string', ()=>{
-            expect(buildQuery('', 'postgres')).toBe('');
-        });
-    });
-});

package/fesm/classes/hybrid-cache.class.js

@@ -1,81 +0,0 @@
-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;
-}
-import { envConfig } from '@flusys/nestjs-core/config';
-import KeyvRedis from '@keyv/redis';
-import { CacheableMemory } from 'cacheable';
-import Keyv from 'keyv';
-export class HybridCache {
-    async get(key) {
-        // Prefer memory first if available
-        if (this.memory) {
-            const value = await this.memory.get(key);
-            if (value !== undefined) return value;
-        }
-        // Fallback to redis
-        if (this.redis) {
-            const value = await this.redis.get(key);
-            if (value !== undefined && this.memory) {
-                // backfill L1 memory cache
-                await this.memory.set(key, value);
-            }
-            return value;
-        }
-        return undefined;
-    }
-    async set(key, value, ttl) {
-        if (this.memory) {
-            await this.memory.set(key, value, ttl);
-        }
-        if (this.redis) {
-            await this.redis.set(key, value, ttl);
-        }
-    }
-    async del(key) {
-        if (this.memory) {
-            await this.memory.delete(key);
-        }
-        if (this.redis) {
-            await this.redis.delete(key);
-        }
-    }
-    async reset() {
-        if (this.memory) {
-            await this.memory.clear();
-        }
-    }
-    async resetL2() {
-        if (this.redis) {
-            await this.redis.clear();
-        }
-    }
-    constructor(memoryTtl = 60 * 1000, memorySize = 5000){
-        _define_property(this, "memory", void 0);
-        _define_property(this, "redis", void 0);
-        // Default to 'memory' if not specified
-        const useCacheLabel = envConfig.tryGetValue('USE_CACHE_LABEL', false) || 'memory';
-        if (useCacheLabel === 'memory' || useCacheLabel === 'hybrid') {
-            this.memory = new Keyv({
-                store: new CacheableMemory({
-                    ttl: memoryTtl,
-                    lruSize: memorySize
-                })
-            });
-        }
-        if (useCacheLabel === 'redis' || useCacheLabel === 'hybrid') {
-            this.redis = new Keyv({
-                store: new KeyvRedis(envConfig.getRedisUrl())
-            });
-        }
-    }
-}

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

@@ -1,164 +0,0 @@
-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(()=>({}))
-    }));
-import { HybridCache } from './hybrid-cache.class';
-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 HybridCache();
-            expect(KeyvCtor).toHaveBeenCalledTimes(1);
-        });
-        it('should create only a memory store for "memory" mode', ()=>{
-            mockTryGetValue.mockReturnValue('memory');
-            new HybridCache();
-            expect(KeyvCtor).toHaveBeenCalledTimes(1);
-        });
-        it('should create only a redis store for "redis" mode', async ()=>{
-            mockTryGetValue.mockReturnValue('redis');
-            const cache = new 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 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 HybridCache(30_000, 100);
-            expect(CacheableMemory).toHaveBeenCalledWith({
-                ttl: 30_000,
-                lruSize: 100
-            });
-        });
-    });
-    describe('get (hybrid mode)', ()=>{
-        let cache;
-        beforeEach(()=>{
-            mockTryGetValue.mockReturnValue('hybrid');
-            cache = new 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 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 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 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 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 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 HybridCache();
-            await cache.reset();
-            expect(mockKeyvClear).toHaveBeenCalledTimes(1);
-        });
-        it('resetL2 should clear only the redis store', async ()=>{
-            mockTryGetValue.mockReturnValue('hybrid');
-            const cache = new 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 HybridCache();
-            await expect(cache.reset()).resolves.toBeUndefined();
-            expect(mockKeyvClear).not.toHaveBeenCalled();
-        });
-    });
-});