@flusys/nestjs-shared 6.0.2 → 6.1.0

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

@@ -0,0 +1,84 @@
+"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/html-sanitizer.util.spec.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _htmlsanitizerutil = require("./html-sanitizer.util");
+describe('html-sanitizer.util', ()=>{
+    describe('escapeHtml', ()=>{
+        it('should escape all special HTML characters', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;');
+        });
+        it('should escape ampersands', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)('a & b')).toBe('a &amp; b');
+        });
+        it('should escape single quotes, backticks, and equals signs', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)(`a='b' c=\`d\``)).toBe('a&#x3D;&#x27;b&#x27; c&#x3D;&#x60;d&#x60;');
+        });
+        it('should return an empty string for empty input', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)('')).toBe('');
+        });
+        it('should return input unchanged when it has no special characters', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)('Hello World 123')).toBe('Hello World 123');
+        });
+        it('should return non-string input coerced via nullish fallback', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtml)(null)).toBe('');
+            expect((0, _htmlsanitizerutil.escapeHtml)(undefined)).toBe('');
+        });
+        it('should return non-string, truthy input unchanged (not throw)', ()=>{
+            // e.g. a number passed at runtime despite the TS signature
+            expect((0, _htmlsanitizerutil.escapeHtml)(42)).toBe(42);
+        });
+    });
+    describe('escapeHtmlVariables', ()=>{
+        it('should escape string values', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)({
+                name: '<b>bold</b>'
+            })).toEqual({
+                name: '&lt;b&gt;bold&lt;&#x2F;b&gt;'
+            });
+        });
+        it('should convert numbers and booleans to strings without escaping', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)({
+                count: 5,
+                active: true
+            })).toEqual({
+                count: '5',
+                active: 'true'
+            });
+        });
+        it('should stringify and escape object/array values', ()=>{
+            const result = (0, _htmlsanitizerutil.escapeHtmlVariables)({
+                meta: {
+                    a: '<x>'
+                }
+            });
+            expect(result.meta).toBe((0, _htmlsanitizerutil.escapeHtml)(JSON.stringify({
+                a: '<x>'
+            })));
+        });
+        it('should convert null/undefined values to empty string', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)({
+                a: null,
+                b: undefined
+            })).toEqual({
+                a: '',
+                b: ''
+            });
+        });
+        it('should return an empty object for null/non-object input', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)(null)).toEqual({});
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)(undefined)).toEqual({});
+        });
+        it('should return an empty object for an empty input object', ()=>{
+            expect((0, _htmlsanitizerutil.escapeHtmlVariables)({})).toEqual({});
+        });
+    });
+});

package/cjs/utils/permission-cache-key.util.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _permissioncachekeyutil = require("./permission-cache-key.util");
+describe('permission-cache-key.util', ()=>{
+    describe('buildPermissionCacheKey', ()=>{
+        it('should build a user-scoped key when no config is provided', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1'
+            });
+            expect(key).toBe(_permissioncachekeyutil.DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+        it('should build a user-scoped key when company feature is disabled', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: 'company-1'
+            }, {
+                enableCompanyFeature: false
+            });
+            expect(key).toBe(_permissioncachekeyutil.DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+        it('should build a user-scoped key when company feature enabled but no companyId given', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1'
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(_permissioncachekeyutil.DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+        it('should build a company-scoped key when company feature is enabled and companyId is present', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(_permissioncachekeyutil.DEFAULT_COMPANY_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1').replace('{companyId}', 'company-1').replace('{branchId}', 'branch-1'));
+        });
+        it('should default branchId placeholder to "null" when branchId is missing', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: 'company-1'
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toContain(':branch:null:');
+        });
+        it('should default branchId placeholder to "null" when branchId is explicitly null', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: 'company-1',
+                branchId: null
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toContain(':branch:null:');
+        });
+        it('should use a custom userPermissionKeyFormat when provided', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1'
+            }, {
+                userPermissionKeyFormat: 'custom:{userId}'
+            });
+            expect(key).toBe('custom:user-1');
+        });
+        it('should use a custom companyPermissionKeyFormat when provided', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: 'company-1'
+            }, {
+                enableCompanyFeature: true,
+                companyPermissionKeyFormat: 'custom:{companyId}:{userId}:{branchId}'
+            });
+            expect(key).toBe('custom:company-1:user-1:null');
+        });
+        it('should treat an empty-string companyId as no company scope', ()=>{
+            const key = (0, _permissioncachekeyutil.buildPermissionCacheKey)({
+                userId: 'user-1',
+                companyId: ''
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(_permissioncachekeyutil.DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+    });
+});

package/cjs/utils/query-helpers.util.spec.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _queryhelpersutil = require("./query-helpers.util");
+function createMockQueryBuilder() {
+    return {
+        andWhere: jest.fn().mockReturnThis()
+    };
+}
+describe('query-helpers.util', ()=>{
+    describe('applyCompanyFilter', ()=>{
+        it('should apply the company filter when feature enabled and user has companyId', ()=>{
+            const query = createMockQueryBuilder();
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: true,
+                entityAlias: 'file'
+            }, user);
+            expect(query.andWhere).toHaveBeenCalledWith('file.companyId = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('should use a custom column name when provided', ()=>{
+            const query = createMockQueryBuilder();
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: true,
+                entityAlias: 'file',
+                columnName: 'company_id'
+            }, user);
+            expect(query.andWhere).toHaveBeenCalledWith('file.company_id = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('should not apply filter when feature disabled', ()=>{
+            const query = createMockQueryBuilder();
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: false,
+                entityAlias: 'file'
+            }, user);
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('should not apply filter when user is null', ()=>{
+            const query = createMockQueryBuilder();
+            (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: true,
+                entityAlias: 'file'
+            }, null);
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('should not apply filter when user has no companyId', ()=>{
+            const query = createMockQueryBuilder();
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: undefined
+            });
+            (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: true,
+                entityAlias: 'file'
+            }, user);
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('should return the same query builder instance', ()=>{
+            const query = createMockQueryBuilder();
+            const result = (0, _queryhelpersutil.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: false,
+                entityAlias: 'file'
+            }, null);
+            expect(result).toBe(query);
+        });
+    });
+    describe('buildCompanyWhereCondition', ()=>{
+        it('should add companyId when feature enabled and user has one', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            const result = (0, _queryhelpersutil.buildCompanyWhereCondition)({
+                id: '1'
+            }, true, user);
+            expect(result).toEqual({
+                id: '1',
+                companyId: 'company-1'
+            });
+        });
+        it('should return base where unchanged when feature disabled', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            const result = (0, _queryhelpersutil.buildCompanyWhereCondition)({
+                id: '1'
+            }, false, user);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+        it('should return base where unchanged when user is null', ()=>{
+            const result = (0, _queryhelpersutil.buildCompanyWhereCondition)({
+                id: '1'
+            }, true, null);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+        it('should return base where unchanged when user has no companyId', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: undefined
+            });
+            const result = (0, _queryhelpersutil.buildCompanyWhereCondition)({
+                id: '1'
+            }, true, user);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+    });
+    describe('hasCompanyId', ()=>{
+        it('should return true for an object with a companyId property', ()=>{
+            expect((0, _queryhelpersutil.hasCompanyId)({
+                companyId: 'company-1'
+            })).toBe(true);
+        });
+        it('should return true even when companyId is explicitly undefined but present', ()=>{
+            expect((0, _queryhelpersutil.hasCompanyId)({
+                companyId: undefined
+            })).toBe(true);
+        });
+        it('should return false for an object without a companyId property', ()=>{
+            expect((0, _queryhelpersutil.hasCompanyId)({
+                id: '1'
+            })).toBe(false);
+        });
+        it('should return false for null', ()=>{
+            expect((0, _queryhelpersutil.hasCompanyId)(null)).toBe(false);
+        });
+        it('should return false for non-object values', ()=>{
+            expect((0, _queryhelpersutil.hasCompanyId)('string')).toBe(false);
+            expect((0, _queryhelpersutil.hasCompanyId)(42)).toBe(false);
+        });
+    });
+    describe('validateCompanyOwnership', ()=>{
+        it('should not throw when feature disabled', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: 'company-2'
+                }, user, false, 'Entity')).not.toThrow();
+        });
+        it('should not throw when user is null', ()=>{
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: 'company-2'
+                }, null, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity has no companyId', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    id: '1'
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity companyId is falsy', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: null
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity companyId matches user companyId', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: 'company-1'
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should throw BadRequestException when entity belongs to a different company', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            expect(()=>(0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: 'company-2'
+                }, user, true, 'Email configuration')).toThrow(_common.BadRequestException);
+        });
+        it('should include the entity name in the thrown exception message', ()=>{
+            const user = (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            });
+            try {
+                (0, _queryhelpersutil.validateCompanyOwnership)({
+                    companyId: 'company-2'
+                }, user, true, 'Email configuration');
+                fail('expected to throw');
+            } catch (error) {
+                expect(error.getResponse().message).toContain('Email configuration');
+            }
+        });
+    });
+});