@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/cjs/modules/utils/utils.service.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "UtilsService", {
-    enumerable: true,
-    get: function() {
-        return UtilsService;
-    }
-});
-const _common = require("@nestjs/common");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-let UtilsService = class UtilsService {
-    // ---------------- CACHE HELPERS ----------------
-    /**
-   * Generate cache key with optional tenant prefix for multi-tenant isolation
-   */ getCacheKey(entityName, params, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        if (entityId) {
-            return `${prefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
-        }
-        return `${prefix}entity_${entityName}_all_${JSON.stringify(params)}`;
-    }
-    /**
-   * Track cache key for later invalidation with optional tenant prefix
-   */ async trackCacheKey(cacheKey, entityName, cacheManager, entityId, tenantId) {
-        try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            if (!keys.includes(cacheKey)) keys.push(cacheKey);
-            await cacheManager.set(trackingKey, keys);
-        } catch  {
-        // Silent failure - cache tracking is non-critical
-        }
-    }
-    /**
-   * Clear cache for entity with optional tenant prefix
-   */ async clearCache(entityName, cacheManager, entityId, tenantId) {
-        try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
-            await cacheManager.del(trackingKey);
-        } catch  {
-        // Silent failure - cache invalidation is non-critical
-        }
-    }
-    // ---------------- STRING HELPERS ----------------
-    /**
-   * Transform string to URL-friendly slug
-   */ transformToSlug(value, salt) {
-        const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
-        return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
-    }
-    /**
-   * Generate random integer between min and max (inclusive)
-   */ getRandomInt(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-    // ---------------- PRIVATE HELPERS ----------------
-    buildTenantPrefix(tenantId) {
-        return tenantId ? `tenant_${tenantId}_` : '';
-    }
-    buildTrackingKey(entityName, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
-    }
-};
-UtilsService = _ts_decorate([
-    (0, _common.Injectable)()
-], UtilsService);

package/cjs/modules/utils/utils.service.spec.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _utilsservice = require("./utils.service");
-describe('UtilsService', ()=>{
-    let service;
-    let mockCache;
-    beforeEach(()=>{
-        service = new _utilsservice.UtilsService();
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            del: jest.fn()
-        };
-    });
-    describe('getCacheKey', ()=>{
-        it('should build an "all" key from the entity name and params when no id is given', ()=>{
-            const key = service.getCacheKey('product', {
-                page: 1
-            });
-            expect(key).toBe('entity_product_all_{"page":1}');
-        });
-        it('should build a per-id key with a select suffix when params are given', ()=>{
-            const key = service.getCacheKey('product', {
-                fields: [
-                    'name'
-                ]
-            }, 'prod-1');
-            expect(key).toBe('entity_product_id_prod-1_select_{"fields":["name"]}');
-        });
-        it('should build a per-id key without a select suffix when params are falsy', ()=>{
-            const key = service.getCacheKey('product', null, 'prod-1');
-            expect(key).toBe('entity_product_id_prod-1');
-        });
-        it('should prefix the key with the tenant id when provided', ()=>{
-            const key = service.getCacheKey('product', {
-                page: 1
-            }, undefined, 'tenant-a');
-            expect(key).toBe('tenant_tenant-a_entity_product_all_{"page":1}');
-        });
-        it('should prefix a per-id key with the tenant id too', ()=>{
-            const key = service.getCacheKey('product', undefined, 'prod-1', 'tenant-a');
-            expect(key).toBe('tenant_tenant-a_entity_product_id_prod-1');
-        });
-    });
-    describe('trackCacheKey', ()=>{
-        it('should create a new tracking list when none exists yet', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should append to an existing tracking list without duplicating entries', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'cache-key-1'
-            ]);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should append a new key alongside existing ones', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'cache-key-1'
-            ]);
-            await service.trackCacheKey('cache-key-2', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1',
-                'cache-key-2'
-            ]);
-        });
-        it('should scope the tracking key by entity id and tenant', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache, 'prod-1', 'tenant-a');
-            expect(mockCache.get).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys');
-            expect(mockCache.set).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should swallow cache read errors without throwing', async ()=>{
-            mockCache.get.mockRejectedValue(new Error('cache down'));
-            await expect(service.trackCacheKey('k', 'product', mockCache)).resolves.toBeUndefined();
-            expect(mockCache.set).not.toHaveBeenCalled();
-        });
-        it('should swallow cache write errors without throwing', async ()=>{
-            mockCache.get.mockResolvedValue([]);
-            mockCache.set.mockRejectedValue(new Error('cache down'));
-            await expect(service.trackCacheKey('k', 'product', mockCache)).resolves.toBeUndefined();
-        });
-    });
-    describe('clearCache', ()=>{
-        it('should delete every tracked key plus the tracking key itself', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1',
-                'k2'
-            ]);
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledWith('k1');
-            expect(mockCache.del).toHaveBeenCalledWith('k2');
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-            expect(mockCache.del).toHaveBeenCalledTimes(3);
-        });
-        it('should only delete the tracking key when no keys were tracked', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledTimes(1);
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-        });
-        it('should continue deleting remaining keys even if one deletion rejects', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1',
-                'k2'
-            ]);
-            mockCache.del.mockImplementation((key)=>key === 'k1' ? Promise.reject(new Error('fail')) : Promise.resolve());
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledWith('k2');
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-        });
-        it('should scope deletion by entity id and tenant', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1'
-            ]);
-            await service.clearCache('product', mockCache, 'prod-1', 'tenant-a');
-            expect(mockCache.get).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys');
-        });
-        it('should swallow errors from the initial cache read', async ()=>{
-            mockCache.get.mockRejectedValue(new Error('cache down'));
-            await expect(service.clearCache('product', mockCache)).resolves.toBeUndefined();
-            expect(mockCache.del).not.toHaveBeenCalled();
-        });
-    });
-    describe('transformToSlug', ()=>{
-        it('should lowercase and dash-separate a normal string', ()=>{
-            expect(service.transformToSlug('Hello World')).toBe('hello-world');
-        });
-        it('should collapse runs of non-alphanumeric characters into a single dash', ()=>{
-            expect(service.transformToSlug('Hello   World!!!')).toBe('hello-world-');
-        });
-        it('should trim leading/trailing whitespace before slugging', ()=>{
-            expect(service.transformToSlug('  Hello World  ')).toBe('hello-world');
-        });
-        it('should append a random numeric salt when requested', ()=>{
-            const randomSpy = jest.spyOn(service, 'getRandomInt').mockReturnValue(42);
-            expect(service.transformToSlug('Hello World', true)).toBe('hello-world-42');
-            randomSpy.mockRestore();
-        });
-        it('should handle an empty string', ()=>{
-            expect(service.transformToSlug('')).toBe('');
-        });
-        it('should handle strings that are entirely non-alphanumeric', ()=>{
-            expect(service.transformToSlug('!!!')).toBe('-');
-        });
-    });
-    describe('getRandomInt', ()=>{
-        it('should return the exact bound when min equals max', ()=>{
-            expect(service.getRandomInt(5, 5)).toBe(5);
-        });
-        it('should stay within an inclusive [min, max] range across many samples', ()=>{
-            for(let i = 0; i < 200; i++){
-                const value = service.getRandomInt(1, 10);
-                expect(value).toBeGreaterThanOrEqual(1);
-                expect(value).toBeLessThanOrEqual(10);
-                expect(Number.isInteger(value)).toBe(true);
-            }
-        });
-    });
-});

package/cjs/utils/date-time.util.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get formatInTimezone () {
-        return formatInTimezone;
-    },
-    get getTodayInTimezone () {
-        return getTodayInTimezone;
-    },
-    get localToUtc () {
-        return localToUtc;
-    },
-    get utcToLocal () {
-        return utcToLocal;
-    }
-});
-function getOffsetMinutes(utcDate, timezone) {
-    const extract = (tz)=>{
-        const parts = new Intl.DateTimeFormat('en-US', {
-            timeZone: tz,
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-            hour12: false
-        }).formatToParts(utcDate);
-        const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
-                x.type,
-                parseInt(x.value)
-            ]));
-        return Date.UTC(p['year'], p['month'] - 1, p['day'], p['hour'], p['minute'], p['second']);
-    };
-    return (extract(timezone) - extract('UTC')) / 60_000;
-}
-function localToUtc(dateStr, timeStr, timezone) {
-    const [year, month, day] = dateStr.split('-').map(Number);
-    const [hours, minutes] = timeStr.split(':').map(Number);
-    const approx = new Date(Date.UTC(year, month - 1, day, hours, minutes, 0));
-    const offset = getOffsetMinutes(approx, timezone);
-    const utcDate = new Date(approx.getTime() - offset * 60_000);
-    // DST boundary guard: re-check offset after adjustment
-    const finalOffset = getOffsetMinutes(utcDate, timezone);
-    return finalOffset !== offset ? new Date(approx.getTime() - finalOffset * 60_000) : utcDate;
-}
-function utcToLocal(utcDate, timezone) {
-    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
-    const parts = new Intl.DateTimeFormat('en-CA', {
-        timeZone: timezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        hour12: false
-    }).formatToParts(d);
-    const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
-            x.type,
-            x.value
-        ]));
-    // en-CA formats midnight hour as '24' — normalize to '00'
-    const hour = p['hour'] === '24' ? '00' : p['hour'];
-    return {
-        date: `${p['year']}-${p['month']}-${p['day']}`,
-        time: `${hour}:${p['minute']}`,
-        display: new Intl.DateTimeFormat('en-US', {
-            timeZone: timezone,
-            dateStyle: 'medium',
-            timeStyle: 'short'
-        }).format(d)
-    };
-}
-function formatInTimezone(utcDate, timezone, options = {
-    dateStyle: 'medium',
-    timeStyle: 'short'
-}) {
-    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
-    return new Intl.DateTimeFormat('en-US', {
-        ...options,
-        timeZone: timezone
-    }).format(d);
-}
-function getTodayInTimezone(timezone) {
-    return utcToLocal(new Date(), timezone).date;
-}

package/cjs/utils/date-time.util.spec.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _datetimeutil = require("./date-time.util");
-describe('date-time.util', ()=>{
-    describe('localToUtc', ()=>{
-        it('should convert a local date/time in a fixed-offset timezone to UTC', ()=>{
-            // Asia/Dhaka is UTC+6, no DST
-            const result = (0, _datetimeutil.localToUtc)('2026-01-15', '10:00', 'Asia/Dhaka');
-            expect(result.toISOString()).toBe('2026-01-15T04:00:00.000Z');
-        });
-        it('should convert local time in UTC timezone unchanged', ()=>{
-            const result = (0, _datetimeutil.localToUtc)('2026-06-01', '12:30', 'UTC');
-            expect(result.toISOString()).toBe('2026-06-01T12:30:00.000Z');
-        });
-        it('should handle a negative UTC offset timezone (America/New_York in winter, no DST)', ()=>{
-            // America/New_York is UTC-5 in January (standard time, no DST)
-            const result = (0, _datetimeutil.localToUtc)('2026-01-15', '09:00', 'America/New_York');
-            expect(result.toISOString()).toBe('2026-01-15T14:00:00.000Z');
-        });
-        it('should account for DST when converting a summer date in America/New_York (UTC-4)', ()=>{
-            const result = (0, _datetimeutil.localToUtc)('2026-07-15', '09:00', 'America/New_York');
-            expect(result.toISOString()).toBe('2026-07-15T13:00:00.000Z');
-        });
-    });
-    describe('utcToLocal', ()=>{
-        it('should convert a UTC Date to local date/time/display parts', ()=>{
-            const result = (0, _datetimeutil.utcToLocal)(new Date('2026-01-15T04:00:00.000Z'), 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('10:00');
-            expect(result.display).toEqual(expect.any(String));
-        });
-        it('should accept a UTC date string as input', ()=>{
-            const result = (0, _datetimeutil.utcToLocal)('2026-01-15T04:00:00.000Z', 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('10:00');
-        });
-        it('should normalize midnight (en-CA "24") to "00"', ()=>{
-            // 00:00 Dhaka time == 18:00 UTC the previous day
-            const result = (0, _datetimeutil.utcToLocal)('2026-01-14T18:00:00.000Z', 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('00:00');
-        });
-    });
-    describe('formatInTimezone', ()=>{
-        it('should format a date in the given timezone with default options', ()=>{
-            const result = (0, _datetimeutil.formatInTimezone)('2026-01-15T04:00:00.000Z', 'Asia/Dhaka');
-            expect(typeof result).toBe('string');
-            expect(result.length).toBeGreaterThan(0);
-        });
-        it('should respect custom Intl.DateTimeFormatOptions', ()=>{
-            const result = (0, _datetimeutil.formatInTimezone)('2026-01-15T04:00:00.000Z', 'UTC', {
-                year: 'numeric'
-            });
-            expect(result).toBe('2026');
-        });
-        it('should accept a Date object as input', ()=>{
-            const result = (0, _datetimeutil.formatInTimezone)(new Date('2026-01-15T04:00:00.000Z'), 'UTC', {
-                year: 'numeric'
-            });
-            expect(result).toBe('2026');
-        });
-    });
-    describe('getTodayInTimezone', ()=>{
-        it('should return a date string in YYYY-MM-DD format', ()=>{
-            const result = (0, _datetimeutil.getTodayInTimezone)('UTC');
-            expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        });
-        it('should match utcToLocal(now, timezone).date', ()=>{
-            const now = new Date();
-            const expected = (0, _datetimeutil.utcToLocal)(now, 'Asia/Dhaka').date;
-            expect((0, _datetimeutil.getTodayInTimezone)('Asia/Dhaka')).toBe(expected);
-        });
-    });
-    describe('round-trip', ()=>{
-        it('should round-trip localToUtc -> utcToLocal for a fixed-offset zone', ()=>{
-            const utc = (0, _datetimeutil.localToUtc)('2026-03-10', '08:15', 'Asia/Dhaka');
-            const back = (0, _datetimeutil.utcToLocal)(utc, 'Asia/Dhaka');
-            expect(back.date).toBe('2026-03-10');
-            expect(back.time).toBe('08:15');
-        });
-    });
-});

package/cjs/utils/event-pattern.util.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get isMultiWildcard () {
-        return isMultiWildcard;
-    },
-    get matchEventPattern () {
-        return matchEventPattern;
-    },
-    get sanitizeEventPayload () {
-        return sanitizeEventPayload;
-    }
-});
-const SENSITIVE_KEYS = [
-    'password',
-    'secret',
-    'token',
-    'apikey',
-    'authorization',
-    'salt',
-    'hash',
-    'credential',
-    'accesskey',
-    'accountkey',
-    'privatekey',
-    'connectionstring',
-    'passphrase'
-];
-/**
- * Matched whole, not as a substring - `pass` must be redacted without also
- * redacting `bypassCache`, and a storage row's `key` is a path, not a secret.
- *
- * `config` is the provider settings blob on the storage and email config rows:
- * S3, Azure, SFTP and SMTP credentials live in it, so it never leaves the
- * process, even though the row itself still publishes.
- */ const SENSITIVE_EXACT_KEYS = [
-    'pass',
-    'pwd',
-    'config'
-];
-const REDACTED = '[REDACTED]';
-const CIRCULAR = '[CIRCULAR]';
-const TRUNCATED = '[TRUNCATED]';
-const BINARY = '[BINARY]';
-const MAX_DEPTH = 8;
-function matchEventPattern(pattern, eventName) {
-    if (pattern === eventName) return true;
-    const patternSegments = pattern.split('.');
-    const nameSegments = eventName.split('.');
-    return matchSegments(patternSegments, 0, nameSegments, 0);
-}
-function isMultiWildcard(segment) {
-    return segment === '#' || segment === '**';
-}
-function matchSegments(pattern, patternIndex, name, nameIndex) {
-    if (patternIndex === pattern.length) return nameIndex === name.length;
-    const segment = pattern[patternIndex];
-    if (isMultiWildcard(segment)) {
-        for(let skip = nameIndex; skip <= name.length; skip++){
-            if (matchSegments(pattern, patternIndex + 1, name, skip)) return true;
-        }
-        return false;
-    }
-    if (nameIndex === name.length) return false;
-    if (segment !== '*' && segment !== name[nameIndex]) return false;
-    return matchSegments(pattern, patternIndex + 1, name, nameIndex + 1);
-}
-function sanitizeEventPayload(value) {
-    return sanitizeValue(value, new WeakSet(), 0);
-}
-function sanitizeValue(value, ancestors, depth) {
-    if (value === null || typeof value !== 'object') return value;
-    if (value instanceof Date) return value;
-    if (Buffer.isBuffer(value)) return BINARY;
-    if (ancestors.has(value)) return CIRCULAR;
-    if (depth >= MAX_DEPTH) return TRUNCATED;
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value)) {
-            return value.map((item)=>sanitizeValue(item, ancestors, depth + 1));
-        }
-        const sanitized = {};
-        for (const [key, entry] of Object.entries(value)){
-            sanitized[key] = isSensitiveKey(key) ? REDACTED : sanitizeValue(entry, ancestors, depth + 1);
-        }
-        return sanitized;
-    } finally{
-        ancestors.delete(value);
-    }
-}
-function isSensitiveKey(key) {
-    const lowered = key.toLowerCase();
-    if (SENSITIVE_EXACT_KEYS.includes(lowered)) return true;
-    return SENSITIVE_KEYS.some((sensitive)=>lowered.includes(sensitive));
-}