@flusys/nestjs-shared 6.0.2 → 6.1.0

package/fesm/utils/html-sanitizer.util.spec.js

@@ -0,0 +1,72 @@
+import { escapeHtml, escapeHtmlVariables } from './html-sanitizer.util';
+describe('html-sanitizer.util', ()=>{
+    describe('escapeHtml', ()=>{
+        it('should escape all special HTML characters', ()=>{
+            expect(escapeHtml('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;');
+        });
+        it('should escape ampersands', ()=>{
+            expect(escapeHtml('a & b')).toBe('a &amp; b');
+        });
+        it('should escape single quotes, backticks, and equals signs', ()=>{
+            expect(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(escapeHtml('')).toBe('');
+        });
+        it('should return input unchanged when it has no special characters', ()=>{
+            expect(escapeHtml('Hello World 123')).toBe('Hello World 123');
+        });
+        it('should return non-string input coerced via nullish fallback', ()=>{
+            expect(escapeHtml(null)).toBe('');
+            expect(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(escapeHtml(42)).toBe(42);
+        });
+    });
+    describe('escapeHtmlVariables', ()=>{
+        it('should escape string values', ()=>{
+            expect(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(escapeHtmlVariables({
+                count: 5,
+                active: true
+            })).toEqual({
+                count: '5',
+                active: 'true'
+            });
+        });
+        it('should stringify and escape object/array values', ()=>{
+            const result = escapeHtmlVariables({
+                meta: {
+                    a: '<x>'
+                }
+            });
+            expect(result.meta).toBe(escapeHtml(JSON.stringify({
+                a: '<x>'
+            })));
+        });
+        it('should convert null/undefined values to empty string', ()=>{
+            expect(escapeHtmlVariables({
+                a: null,
+                b: undefined
+            })).toEqual({
+                a: '',
+                b: ''
+            });
+        });
+        it('should return an empty object for null/non-object input', ()=>{
+            expect(escapeHtmlVariables(null)).toEqual({});
+            expect(escapeHtmlVariables(undefined)).toEqual({});
+        });
+        it('should return an empty object for an empty input object', ()=>{
+            expect(escapeHtmlVariables({})).toEqual({});
+        });
+    });
+});

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

@@ -0,0 +1,84 @@
+import { buildPermissionCacheKey, DEFAULT_COMPANY_PERMISSION_KEY_FORMAT, DEFAULT_USER_PERMISSION_KEY_FORMAT } from './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 = buildPermissionCacheKey({
+                userId: 'user-1'
+            });
+            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+        it('should build a user-scoped key when company feature is disabled', ()=>{
+            const key = buildPermissionCacheKey({
+                userId: 'user-1',
+                companyId: 'company-1'
+            }, {
+                enableCompanyFeature: false
+            });
+            expect(key).toBe(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 = buildPermissionCacheKey({
+                userId: 'user-1'
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(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 = buildPermissionCacheKey({
+                userId: 'user-1',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(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 = 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 = 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 = buildPermissionCacheKey({
+                userId: 'user-1'
+            }, {
+                userPermissionKeyFormat: 'custom:{userId}'
+            });
+            expect(key).toBe('custom:user-1');
+        });
+        it('should use a custom companyPermissionKeyFormat when provided', ()=>{
+            const key = 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 = buildPermissionCacheKey({
+                userId: 'user-1',
+                companyId: ''
+            }, {
+                enableCompanyFeature: true
+            });
+            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
+        });
+    });
+});

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

@@ -0,0 +1,205 @@
+import { BadRequestException } from '@nestjs/common';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { applyCompanyFilter, buildCompanyWhereCondition, hasCompanyId, validateCompanyOwnership } from './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 = buildMockUser({
+                companyId: 'company-1'
+            });
+            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 = buildMockUser({
+                companyId: 'company-1'
+            });
+            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 = buildMockUser({
+                companyId: 'company-1'
+            });
+            applyCompanyFilter(query, {
+                isCompanyFeatureEnabled: false,
+                entityAlias: 'file'
+            }, user);
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('should not apply filter when user is null', ()=>{
+            const query = createMockQueryBuilder();
+            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 = buildMockUser({
+                companyId: undefined
+            });
+            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 = 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 = buildMockUser({
+                companyId: 'company-1'
+            });
+            const result = buildCompanyWhereCondition({
+                id: '1'
+            }, true, user);
+            expect(result).toEqual({
+                id: '1',
+                companyId: 'company-1'
+            });
+        });
+        it('should return base where unchanged when feature disabled', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            const result = buildCompanyWhereCondition({
+                id: '1'
+            }, false, user);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+        it('should return base where unchanged when user is null', ()=>{
+            const result = buildCompanyWhereCondition({
+                id: '1'
+            }, true, null);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+        it('should return base where unchanged when user has no companyId', ()=>{
+            const user = buildMockUser({
+                companyId: undefined
+            });
+            const result = buildCompanyWhereCondition({
+                id: '1'
+            }, true, user);
+            expect(result).toEqual({
+                id: '1'
+            });
+        });
+    });
+    describe('hasCompanyId', ()=>{
+        it('should return true for an object with a companyId property', ()=>{
+            expect(hasCompanyId({
+                companyId: 'company-1'
+            })).toBe(true);
+        });
+        it('should return true even when companyId is explicitly undefined but present', ()=>{
+            expect(hasCompanyId({
+                companyId: undefined
+            })).toBe(true);
+        });
+        it('should return false for an object without a companyId property', ()=>{
+            expect(hasCompanyId({
+                id: '1'
+            })).toBe(false);
+        });
+        it('should return false for null', ()=>{
+            expect(hasCompanyId(null)).toBe(false);
+        });
+        it('should return false for non-object values', ()=>{
+            expect(hasCompanyId('string')).toBe(false);
+            expect(hasCompanyId(42)).toBe(false);
+        });
+    });
+    describe('validateCompanyOwnership', ()=>{
+        it('should not throw when feature disabled', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            expect(()=>validateCompanyOwnership({
+                    companyId: 'company-2'
+                }, user, false, 'Entity')).not.toThrow();
+        });
+        it('should not throw when user is null', ()=>{
+            expect(()=>validateCompanyOwnership({
+                    companyId: 'company-2'
+                }, null, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity has no companyId', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            expect(()=>validateCompanyOwnership({
+                    id: '1'
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity companyId is falsy', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            expect(()=>validateCompanyOwnership({
+                    companyId: null
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should not throw when entity companyId matches user companyId', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            expect(()=>validateCompanyOwnership({
+                    companyId: 'company-1'
+                }, user, true, 'Entity')).not.toThrow();
+        });
+        it('should throw BadRequestException when entity belongs to a different company', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            expect(()=>validateCompanyOwnership({
+                    companyId: 'company-2'
+                }, user, true, 'Email configuration')).toThrow(BadRequestException);
+        });
+        it('should include the entity name in the thrown exception message', ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            try {
+                validateCompanyOwnership({
+                    companyId: 'company-2'
+                }, user, true, 'Email configuration');
+                fail('expected to throw');
+            } catch (error) {
+                expect(error.getResponse().message).toContain('Email configuration');
+            }
+        });
+    });
+});

package/fesm/utils/request.util.spec.js

@@ -0,0 +1,245 @@
+const isProductionMock = jest.fn();
+const getOriginsMock = jest.fn();
+jest.mock('@flusys/nestjs-core/config', ()=>({
+        envConfig: {
+            isProduction: ()=>isProductionMock(),
+            getOrigins: ()=>getOriginsMock()
+        }
+    }));
+import { buildCookieOptions, buildFrontendUrl, extractFrontendUrl, isBrowserRequest, parseDurationToMs } from './request.util';
+function buildRequest(overrides = {}) {
+    return {
+        headers: {},
+        hostname: 'app.example.com',
+        secure: false,
+        get: jest.fn((name)=>overrides.headers?.[name.toLowerCase()]),
+        ...overrides
+    };
+}
+describe('request.util', ()=>{
+    beforeEach(()=>{
+        isProductionMock.mockReset().mockReturnValue(false);
+        getOriginsMock.mockReset().mockReturnValue([]);
+    });
+    describe('isBrowserRequest', ()=>{
+        it('should return true when x-client-type header is "browser"', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'x-client-type': 'browser'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(true);
+        });
+        it('should return true when x-client-type header is "web"', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'x-client-type': 'WEB'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(true);
+        });
+        it('should return false when x-client-type header is a non-browser value', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'x-client-type': 'mobile'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(false);
+        });
+        it('should return true when accept header includes text/html', ()=>{
+            const req = buildRequest({
+                headers: {
+                    accept: 'text/html,application/xhtml+xml'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(true);
+        });
+        it('should return true for a recognized browser user-agent', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'user-agent': 'Mozilla/5.0 Chrome/100.0 Safari/537.36'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(true);
+        });
+        it('should return false for Postman user-agent even if it matches browser patterns', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'user-agent': 'PostmanRuntime/7.0 chrome'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(false);
+        });
+        it('should return false when no headers indicate a browser', ()=>{
+            const req = buildRequest({
+                headers: {
+                    'user-agent': 'curl/7.79.1'
+                }
+            });
+            expect(isBrowserRequest(req)).toBe(false);
+        });
+    });
+    describe('buildCookieOptions', ()=>{
+        it('should mark cookies secure and sameSite strict in production', ()=>{
+            isProductionMock.mockReturnValue(true);
+            const req = buildRequest({
+                headers: {}
+            });
+            const options = buildCookieOptions(req);
+            expect(options.secure).toBe(true);
+            expect(options.sameSite).toBe('strict');
+        });
+        it('should mark cookies insecure and sameSite lax in dev with no forwarded proto', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {}
+            });
+            const options = buildCookieOptions(req);
+            expect(options.secure).toBe(false);
+            expect(options.sameSite).toBe('lax');
+        });
+        it('should treat x-forwarded-proto: https as secure', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {
+                    'x-forwarded-proto': 'https'
+                }
+            });
+            const options = buildCookieOptions(req);
+            expect(options.secure).toBe(true);
+            expect(options.sameSite).toBe('strict');
+        });
+        it('should treat an https origin header as secure', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {
+                    origin: 'https://app.example.com'
+                }
+            });
+            const options = buildCookieOptions(req);
+            expect(options.secure).toBe(true);
+        });
+        it('should treat req.secure as secure', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {},
+                secure: true
+            });
+            const options = buildCookieOptions(req);
+            expect(options.secure).toBe(true);
+        });
+        it('should not set a domain for a localhost hostname', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {},
+                hostname: 'localhost'
+            });
+            const options = buildCookieOptions(req);
+            expect(options.domain).toBeUndefined();
+        });
+        it('should not set a domain for a bare two-part hostname', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {},
+                hostname: 'example.com'
+            });
+            const options = buildCookieOptions(req);
+            expect(options.domain).toBeUndefined();
+        });
+        it('should set a leading-dot domain for a subdomain hostname', ()=>{
+            isProductionMock.mockReturnValue(false);
+            const req = buildRequest({
+                headers: {},
+                hostname: 'app.example.com'
+            });
+            const options = buildCookieOptions(req);
+            expect(options.domain).toBe('.example.com');
+        });
+    });
+    describe('parseDurationToMs', ()=>{
+        it('should parse seconds', ()=>{
+            expect(parseDurationToMs('30s')).toBe(30 * 1000);
+        });
+        it('should parse minutes', ()=>{
+            expect(parseDurationToMs('15m')).toBe(15 * 60 * 1000);
+        });
+        it('should parse hours', ()=>{
+            expect(parseDurationToMs('2h')).toBe(2 * 60 * 60 * 1000);
+        });
+        it('should parse days', ()=>{
+            expect(parseDurationToMs('7d')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('should parse weeks', ()=>{
+            expect(parseDurationToMs('2w')).toBe(2 * 7 * 24 * 60 * 60 * 1000);
+        });
+        it('should return the default when the string does not match the pattern', ()=>{
+            expect(parseDurationToMs('garbage')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('should return a custom default when provided and pattern does not match', ()=>{
+            expect(parseDurationToMs('garbage', 12345)).toBe(12345);
+        });
+    });
+    describe('extractFrontendUrl', ()=>{
+        it('should return the matched allowed origin when the request origin starts with it', ()=>{
+            getOriginsMock.mockReturnValue([
+                'https://app.example.com'
+            ]);
+            const req = buildRequest({
+                headers: {
+                    origin: 'https://app.example.com'
+                },
+                get: jest.fn((name)=>{
+                    if (name === 'origin') return 'https://app.example.com';
+                    return undefined;
+                })
+            });
+            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
+        });
+        it('should fall back to referer when origin header is absent', ()=>{
+            getOriginsMock.mockReturnValue([
+                'https://app.example.com'
+            ]);
+            const req = buildRequest({
+                get: jest.fn((name)=>{
+                    if (name === 'referer') return 'https://app.example.com/some/path';
+                    return undefined;
+                })
+            });
+            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
+        });
+        it('should fall back to protocol + host when no origin matches an allowed origin', ()=>{
+            getOriginsMock.mockReturnValue([
+                'https://other.example.com'
+            ]);
+            const req = buildRequest({
+                get: jest.fn((name)=>{
+                    if (name === 'host') return 'app.example.com';
+                    return undefined;
+                }),
+                protocol: 'https'
+            });
+            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
+        });
+        it('should throw when no origin/referer matches and no host header is present', ()=>{
+            getOriginsMock.mockReturnValue([]);
+            const req = buildRequest({
+                get: jest.fn(()=>undefined)
+            });
+            expect(()=>extractFrontendUrl(req)).toThrow('Unable to determine frontend URL from request');
+        });
+    });
+    describe('buildFrontendUrl', ()=>{
+        it('should append the path to the resolved frontend base URL', ()=>{
+            getOriginsMock.mockReturnValue([
+                'https://app.example.com'
+            ]);
+            const req = buildRequest({
+                get: jest.fn((name)=>{
+                    if (name === 'origin') return 'https://app.example.com';
+                    return undefined;
+                })
+            });
+            expect(buildFrontendUrl(req, '/reset-password?token=abc')).toBe('https://app.example.com/reset-password?token=abc');
+        });
+    });
+});

package/fesm/utils/string.util.spec.js

@@ -0,0 +1,59 @@
+import { generateSlug, generateUniqueSlug } from './string.util';
+describe('string.util', ()=>{
+    describe('generateSlug', ()=>{
+        it('should lowercase and hyphenate a plain string', ()=>{
+            expect(generateSlug('My Company Name')).toBe('my-company-name');
+        });
+        it('should strip special characters', ()=>{
+            expect(generateSlug('Hello World!')).toBe('hello-world');
+        });
+        it('should collapse repeated whitespace and hyphens', ()=>{
+            expect(generateSlug('Foo   Bar--Baz')).toBe('foo-bar-baz');
+        });
+        it('should trim leading/trailing hyphens produced by punctuation', ()=>{
+            expect(generateSlug('  -Hello-  ')).toBe('hello');
+        });
+        it('should truncate to maxLength', ()=>{
+            expect(generateSlug('abcdefghij', 5)).toBe('abcde');
+        });
+        it('should return an empty string for input that is only special characters', ()=>{
+            expect(generateSlug('!!!???')).toBe('');
+        });
+    });
+    describe('generateUniqueSlug', ()=>{
+        it('should return the base slug when there are no collisions', async ()=>{
+            const findMatchingSlugs = jest.fn().mockResolvedValue([]);
+            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
+            expect(slug).toBe('my-company');
+            expect(findMatchingSlugs).toHaveBeenCalledWith('my-company');
+        });
+        it('should return the base slug when only suffixed variants exist', async ()=>{
+            const findMatchingSlugs = jest.fn().mockResolvedValue([
+                'my-company-1'
+            ]);
+            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
+            expect(slug).toBe('my-company');
+        });
+        it('should append the next available numeric suffix on collision', async ()=>{
+            const findMatchingSlugs = jest.fn().mockResolvedValue([
+                'my-company',
+                'my-company-1',
+                'my-company-2'
+            ]);
+            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
+            expect(slug).toBe('my-company-3');
+        });
+        it('should fall back to a random suffix when all 9999 slots are taken', async ()=>{
+            const taken = [
+                'my-company',
+                ...Array.from({
+                    length: 9999
+                }, (_, i)=>`my-company-${i + 1}`)
+            ];
+            const findMatchingSlugs = jest.fn().mockResolvedValue(taken);
+            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
+            expect(slug).toMatch(/^my-company-[a-z0-9]+$/);
+            expect(taken).not.toContain(slug);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "6.0.2",
+  "version": "6.1.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -112,6 +112,6 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.0.2"
+    "@flusys/nestjs-core": "6.1.0"
   }
 }