@flusys/nestjs-auth 6.0.2 → 6.1.1

package/cjs/services/branch.service.spec.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _branchservice = require("./branch.service");
+const _companybranchentity = require("../entities/company-branch.entity");
+const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
+describe('BranchService', ()=>{
+    let service;
+    let mockRepo;
+    let mockAuthConfig;
+    let mockPermissionSyncAdapter;
+    let mockQueryRunner;
+    beforeEach(()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        Object.assign(mockRepo.createQueryBuilder(), {
+            leftJoinAndSelect: jest.fn().mockReturnThis(),
+            addOrderBy: jest.fn().mockReturnThis()
+        });
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockAuthConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockPermissionSyncAdapter = {
+            onBranchDeleted: jest.fn()
+        };
+        service = new _branchservice.BranchService({}, {}, mockDataSourceProvider, mockAuthConfig, mockPermissionSyncAdapter);
+        const permissionRepo = (0, _repositorymock.createMockRepository)();
+        const branchRepo = (0, _repositorymock.createMockRepository)();
+        branchRepo.find.mockResolvedValue([]);
+        mockQueryRunner = {
+            manager: {
+                getRepository: jest.fn().mockImplementation((entity)=>{
+                    if (entity === _usercompanypermissionentity.UserCompanyPermission) return permissionRepo;
+                    if (entity === _companybranchentity.CompanyBranch) return branchRepo;
+                    throw new Error('Unexpected entity');
+                })
+            }
+        };
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('deletes user permissions targeting the deleted branch ids', async ()=>{
+            await service.beforeDeleteOperation({
+                id: [
+                    'branch-1',
+                    'branch-2'
+                ]
+            }, null, mockQueryRunner);
+            const permissionRepo = mockQueryRunner.manager.getRepository(_usercompanypermissionentity.UserCompanyPermission);
+            expect(permissionRepo.delete).toHaveBeenCalledWith({
+                targetId: expect.anything()
+            });
+        });
+        it('handles a single (non-array) branch id', async ()=>{
+            await service.beforeDeleteOperation({
+                id: 'branch-1'
+            }, null, mockQueryRunner);
+            const permissionRepo = mockQueryRunner.manager.getRepository(_usercompanypermissionentity.UserCompanyPermission);
+            expect(permissionRepo.delete).toHaveBeenCalled();
+        });
+        it('does nothing further when no permission sync adapter is configured', async ()=>{
+            service = new _branchservice.BranchService({}, {}, (0, _repositorymock.createMockDataSourceProvider)(mockRepo), mockAuthConfig, undefined);
+            await expect(service.beforeDeleteOperation({
+                id: [
+                    'branch-1'
+                ]
+            }, null, mockQueryRunner)).resolves.toBeUndefined();
+        });
+        it('notifies the permission sync adapter for each deleted branch', async ()=>{
+            const branchRepo = mockQueryRunner.manager.getRepository(_companybranchentity.CompanyBranch);
+            branchRepo.find.mockResolvedValue([
+                {
+                    id: 'branch-1',
+                    companyId: 'company-1'
+                }
+            ]);
+            await service.beforeDeleteOperation({
+                id: [
+                    'branch-1'
+                ]
+            }, null, mockQueryRunner);
+            expect(mockPermissionSyncAdapter.onBranchDeleted).toHaveBeenCalledWith('branch-1', 'company-1');
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('applies the default selected fields when none are provided', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            const { isRaw } = await service.getSelectQuery(qb, null);
+            expect(qb.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'company_branch.id',
+                'company_branch.name',
+                'company_branch.slug'
+            ]));
+            expect(isRaw).toBe(false);
+        });
+        it('honors an explicit select list', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(qb, null, [
+                'id',
+                'name'
+            ]);
+            expect(qb.select).toHaveBeenCalledWith([
+                'company_branch.id',
+                'company_branch.name'
+            ]);
+        });
+    });
+    describe('getGlobalSearchQuery', ()=>{
+        it('adds a LIKE search clause across name/slug/email', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getGlobalSearchQuery(qb, 'acme');
+            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('company_branch.name LIKE'), {
+                search: '%acme%'
+            });
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies a company filter when company feature is enabled and no explicit companyId filter is present', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {}
+            }, {
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('company_branch.company_id = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('does not apply a company filter when companyId is explicitly provided in the filter', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {
+                    companyId: 'explicit-company'
+                }
+            }, {
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            expect(qb.andWhere).not.toHaveBeenCalledWith('company_branch.company_id = :companyId', expect.anything());
+        });
+        it('does not apply a company filter when the company feature is disabled', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(false);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {}
+            }, null);
+            expect(qb.andWhere).not.toHaveBeenCalledWith('company_branch.company_id = :companyId', expect.anything());
+        });
+    });
+});

package/cjs/services/company-selection-session.service.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _companyselectionsessionservice = require("./company-selection-session.service");
+describe('CompanySelectionSessionService', ()=>{
+    let service;
+    let mockCacheManager;
+    beforeEach(()=>{
+        mockCacheManager = {
+            set: jest.fn(),
+            get: jest.fn(),
+            del: jest.fn()
+        };
+        service = new _companyselectionsessionservice.CompanySelectionSessionService(mockCacheManager);
+    });
+    describe('createSession', ()=>{
+        it('stores a session in the cache and returns a session id', async ()=>{
+            const sessionId = await service.createSession('user-1');
+            expect(typeof sessionId).toBe('string');
+            expect(sessionId.length).toBeGreaterThan(0);
+            expect(mockCacheManager.set).toHaveBeenCalledWith(`auth:session:${sessionId}`, expect.objectContaining({
+                sessionId,
+                userId: 'user-1'
+            }), 5 * 60 * 1000);
+        });
+        it('generates unique session ids on successive calls', async ()=>{
+            const first = await service.createSession('user-1');
+            const second = await service.createSession('user-1');
+            expect(first).not.toBe(second);
+        });
+    });
+    describe('getSession', ()=>{
+        it('returns null when no session is cached', async ()=>{
+            mockCacheManager.get.mockResolvedValue(undefined);
+            const result = await service.getSession('missing-session');
+            expect(result).toBeNull();
+        });
+        it('returns the session when present and not expired', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(),
+                expiresAt: new Date(Date.now() + 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.getSession('sess-1');
+            expect(result).toEqual(session);
+            expect(mockCacheManager.get).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+        it('deletes and returns null when the cached session has expired', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(Date.now() - 10 * 60_000),
+                expiresAt: new Date(Date.now() - 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.getSession('sess-1');
+            expect(result).toBeNull();
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+    });
+    describe('consumeSession', ()=>{
+        it('returns and deletes the session when present', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(),
+                expiresAt: new Date(Date.now() + 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.consumeSession('sess-1');
+            expect(result).toEqual(session);
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+        it('returns null and does not delete when session is missing', async ()=>{
+            mockCacheManager.get.mockResolvedValue(undefined);
+            const result = await service.consumeSession('missing');
+            expect(result).toBeNull();
+            expect(mockCacheManager.del).not.toHaveBeenCalled();
+        });
+    });
+    describe('deleteSession', ()=>{
+        it('deletes the session by key', async ()=>{
+            await service.deleteSession('sess-1');
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+    });
+});

package/cjs/services/company.service.spec.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _companyservice = require("./company.service");
+const _companybranchentity = require("../entities/company-branch.entity");
+const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
+describe('CompanyService', ()=>{
+    let service;
+    let mockRepo;
+    let mockPermissionSyncAdapter;
+    let mockQueryRunner;
+    let branchRepo;
+    let permissionRepo;
+    beforeEach(()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockPermissionSyncAdapter = {
+            onCompanyDeleted: jest.fn()
+        };
+        service = new _companyservice.CompanyService({}, {}, mockDataSourceProvider, mockPermissionSyncAdapter);
+        branchRepo = (0, _repositorymock.createMockRepository)();
+        branchRepo.find.mockResolvedValue([]);
+        permissionRepo = (0, _repositorymock.createMockRepository)();
+        mockQueryRunner = {
+            manager: {
+                getRepository: jest.fn().mockImplementation((entity)=>{
+                    if (entity === _companybranchentity.CompanyBranch) return branchRepo;
+                    if (entity === _usercompanypermissionentity.UserCompanyPermission) return permissionRepo;
+                    throw new Error('Unexpected entity');
+                })
+            }
+        };
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('deletes permissions for the companies and their branches', async ()=>{
+            branchRepo.find.mockResolvedValue([
+                {
+                    id: 'branch-1'
+                }
+            ]);
+            await service.beforeDeleteOperation({
+                id: [
+                    'company-1'
+                ]
+            }, null, mockQueryRunner);
+            const deleteArg = permissionRepo.delete.mock.calls[0][0];
+            expect(deleteArg.targetId._value).toEqual(expect.arrayContaining([
+                'company-1',
+                'branch-1'
+            ]));
+        });
+        it('handles a single (non-array) company id', async ()=>{
+            await service.beforeDeleteOperation({
+                id: 'company-1'
+            }, null, mockQueryRunner);
+            expect(branchRepo.find).toHaveBeenCalledWith(expect.objectContaining({
+                where: {
+                    companyId: expect.anything()
+                }
+            }));
+        });
+        it('does nothing further when no permission sync adapter is configured', async ()=>{
+            service = new _companyservice.CompanyService({}, {}, (0, _repositorymock.createMockDataSourceProvider)(mockRepo), undefined);
+            await expect(service.beforeDeleteOperation({
+                id: [
+                    'company-1'
+                ]
+            }, null, mockQueryRunner)).resolves.toBeUndefined();
+        });
+        it('notifies the permission sync adapter for each deleted company', async ()=>{
+            await service.beforeDeleteOperation({
+                id: [
+                    'company-1',
+                    'company-2'
+                ]
+            }, null, mockQueryRunner);
+            expect(mockPermissionSyncAdapter.onCompanyDeleted).toHaveBeenCalledWith('company-1');
+            expect(mockPermissionSyncAdapter.onCompanyDeleted).toHaveBeenCalledWith('company-2');
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('applies the default selected fields when none are provided', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            const { isRaw } = await service.getSelectQuery(qb, null);
+            expect(qb.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'company.id',
+                'company.name',
+                'company.slug'
+            ]));
+            expect(isRaw).toBe(false);
+        });
+        it('honors an explicit select list', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(qb, null, [
+                'id'
+            ]);
+            expect(qb.select).toHaveBeenCalledWith([
+                'company.id'
+            ]);
+        });
+    });
+    describe('getGlobalSearchQuery', ()=>{
+        it('adds a LIKE search clause across name/slug/email', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getGlobalSearchQuery(qb, 'acme');
+            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('company.name LIKE'), {
+                search: '%acme%'
+            });
+        });
+    });
+});

package/cjs/services/user-permission.service.spec.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _userpermissionservice = require("./user-permission.service");
+const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
+function buildPermission(overrides = {}) {
+    return {
+        id: 'perm-uuid-1',
+        userId: 'user-1',
+        permissionType: _usercompanypermissionentity.PermissionType.COMPANY,
+        targetId: 'company-1',
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('UserPermissionService', ()=>{
+    let service;
+    let mockRepo;
+    let mockPermissionSyncAdapter;
+    beforeEach(()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        // The shared query builder mock does not include join helpers used by this service.
+        Object.assign(mockRepo.createQueryBuilder(), {
+            innerJoin: jest.fn().mockReturnThis(),
+            leftJoinAndSelect: jest.fn().mockReturnThis()
+        });
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockPermissionSyncAdapter = {
+            onCompanyDeleted: jest.fn(),
+            onBranchDeleted: jest.fn(),
+            onUserCompanyAccessRevoked: jest.fn(),
+            onUserBranchAccessRevoked: jest.fn()
+        };
+        service = new _userpermissionservice.UserPermissionService(mockDataSourceProvider, mockPermissionSyncAdapter);
+    });
+    describe('findUserPermissions', ()=>{
+        it('finds company permissions with the company relation', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildPermission()
+            ]);
+            const result = await service.findUserPermissions('user-1', _usercompanypermissionentity.PermissionType.COMPANY);
+            expect(result).toHaveLength(1);
+            expect(mockRepo.find).toHaveBeenCalledWith(expect.objectContaining({
+                where: {
+                    userId: 'user-1',
+                    permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                },
+                relations: [
+                    'company'
+                ]
+            }));
+        });
+        it('finds branch permissions with the branch relation', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            await service.findUserPermissions('user-1', _usercompanypermissionentity.PermissionType.BRANCH);
+            expect(mockRepo.find).toHaveBeenCalledWith(expect.objectContaining({
+                relations: [
+                    'branch'
+                ]
+            }));
+        });
+    });
+    describe('assignPermission', ()=>{
+        it('creates and saves a new permission when none exists', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            mockRepo.create.mockReturnValue(buildPermission());
+            mockRepo.save.mockResolvedValue(buildPermission());
+            await service.assignPermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY);
+            expect(mockRepo.create).toHaveBeenCalledWith({
+                userId: 'user-1',
+                permissionType: _usercompanypermissionentity.PermissionType.COMPANY,
+                targetId: 'company-1'
+            });
+            expect(mockRepo.save).toHaveBeenCalled();
+        });
+        it('throws ConflictException when the permission already exists', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildPermission());
+            await expect(service.assignPermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY)).rejects.toThrow(_common.ConflictException);
+            expect(mockRepo.save).not.toHaveBeenCalled();
+        });
+        it('translates a duplicate-entry database error into ConflictException', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            mockRepo.create.mockReturnValue(buildPermission());
+            mockRepo.save.mockRejectedValue({
+                code: 'ER_DUP_ENTRY',
+                message: 'Duplicate entry'
+            });
+            await expect(service.assignPermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY)).rejects.toThrow(_common.ConflictException);
+        });
+        it('rethrows unrelated database errors from save', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            mockRepo.create.mockReturnValue(buildPermission());
+            const dbError = new Error('connection lost');
+            mockRepo.save.mockRejectedValue(dbError);
+            await expect(service.assignPermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY)).rejects.toThrow('connection lost');
+        });
+    });
+    describe('revokePermission', ()=>{
+        it('throws NotFoundException when the permission does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.revokePermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY)).rejects.toThrow(_common.NotFoundException);
+        });
+        it('removes a company permission and cascades revocation to its branches', async ()=>{
+            const companyPermission = buildPermission({
+                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+            });
+            mockRepo.findOne.mockResolvedValue(companyPermission);
+            mockRepo.remove.mockResolvedValue(companyPermission);
+            const branchPermission = buildPermission({
+                id: 'perm-branch-1',
+                permissionType: _usercompanypermissionentity.PermissionType.BRANCH,
+                targetId: 'branch-1'
+            });
+            mockRepo.createQueryBuilder().getMany.mockResolvedValue([
+                branchPermission
+            ]);
+            await service.revokePermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY);
+            expect(mockRepo.remove).toHaveBeenCalledWith(companyPermission);
+            expect(mockRepo.remove).toHaveBeenCalledWith([
+                branchPermission
+            ]);
+            expect(mockPermissionSyncAdapter.onUserCompanyAccessRevoked).toHaveBeenCalledWith('user-1', 'company-1');
+            expect(mockPermissionSyncAdapter.onUserBranchAccessRevoked).toHaveBeenCalledWith('user-1', 'branch-1', 'company-1');
+        });
+        it('removes a branch permission and notifies the sync adapter with its company id', async ()=>{
+            const branchPermission = buildPermission({
+                permissionType: _usercompanypermissionentity.PermissionType.BRANCH,
+                targetId: 'branch-1',
+                branch: {
+                    companyId: 'company-1'
+                }
+            });
+            mockRepo.findOne.mockResolvedValue(branchPermission);
+            mockRepo.remove.mockResolvedValue(branchPermission);
+            await service.revokePermission('user-1', 'branch-1', _usercompanypermissionentity.PermissionType.BRANCH);
+            expect(mockRepo.remove).toHaveBeenCalledWith(branchPermission);
+            expect(mockPermissionSyncAdapter.onUserBranchAccessRevoked).toHaveBeenCalledWith('user-1', 'branch-1', 'company-1');
+        });
+        it('does not notify the sync adapter for a branch permission with no resolvable company', async ()=>{
+            const branchPermission = buildPermission({
+                permissionType: _usercompanypermissionentity.PermissionType.BRANCH,
+                targetId: 'branch-1',
+                branch: undefined
+            });
+            mockRepo.findOne.mockResolvedValue(branchPermission);
+            mockRepo.remove.mockResolvedValue(branchPermission);
+            await service.revokePermission('user-1', 'branch-1', _usercompanypermissionentity.PermissionType.BRANCH);
+            expect(mockPermissionSyncAdapter.onUserBranchAccessRevoked).not.toHaveBeenCalled();
+        });
+        it('works without a permission sync adapter configured', async ()=>{
+            service = new _userpermissionservice.UserPermissionService((0, _repositorymock.createMockDataSourceProvider)(mockRepo), undefined);
+            const companyPermission = buildPermission({
+                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+            });
+            mockRepo.findOne.mockResolvedValue(companyPermission);
+            mockRepo.remove.mockResolvedValue(companyPermission);
+            mockRepo.createQueryBuilder().getMany.mockResolvedValue([]);
+            await expect(service.revokePermission('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY)).resolves.toBeUndefined();
+        });
+    });
+    describe('findUserCompanies', ()=>{
+        it('delegates to findUserPermissions with COMPANY type', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildPermission()
+            ]);
+            const result = await service.findUserCompanies('user-1');
+            expect(result).toHaveLength(1);
+            expect(mockRepo.find).toHaveBeenCalledWith(expect.objectContaining({
+                where: {
+                    userId: 'user-1',
+                    permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                }
+            }));
+        });
+    });
+    describe('findUserBranches', ()=>{
+        it('queries branch permissions for a user without a company filter', async ()=>{
+            mockRepo.createQueryBuilder().getMany.mockResolvedValue([]);
+            await service.findUserBranches('user-1');
+            const qb = mockRepo.createQueryBuilder();
+            expect(qb.where).toHaveBeenCalledWith('permission.userId = :userId', {
+                userId: 'user-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('permission.permissionType = :type', {
+                type: _usercompanypermissionentity.PermissionType.BRANCH
+            });
+        });
+        it('applies an additional company filter when companyId is provided', async ()=>{
+            mockRepo.createQueryBuilder().getMany.mockResolvedValue([]);
+            await service.findUserBranches('user-1', 'company-1');
+            const qb = mockRepo.createQueryBuilder();
+            expect(qb.andWhere).toHaveBeenCalledWith('branch.companyId = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+    });
+});