@flusys/nestjs-iam 6.0.2 → 6.1.0

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

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _roleentity = require("../entities/role.entity");
+const _rolewithcompanyentity = require("../entities/role-with-company.entity");
+const _iamconfigservice = require("./iam-config.service");
+const _iamdatasourceservice = require("./iam-datasource.service");
+const _permissioncacheservice = require("./permission-cache.service");
+const _roleservice = require("./role.service");
+function buildRole(overrides = {}) {
+    return {
+        id: 'role-uuid-1',
+        readOnly: false,
+        name: 'Manager',
+        description: null,
+        isActive: true,
+        serial: 1,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('RoleService', ()=>{
+    let service;
+    let mockRepo;
+    let mockIamConfigService;
+    let mockPermissionCacheService;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockIamConfigService = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockPermissionCacheService = {
+            invalidateUsers: jest.fn()
+        };
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _roleservice.RoleService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: _iamconfigservice.IAMConfigService,
+                    useValue: mockIamConfigService
+                },
+                {
+                    provide: _iamdatasourceservice.IAMDataSourceService,
+                    useValue: mockDataSourceProvider
+                },
+                {
+                    provide: _permissioncacheservice.PermissionCacheService,
+                    useValue: mockPermissionCacheService
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_roleservice.RoleService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to Role when the company feature is disabled', ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            expect(service.resolveEntity()).toBe(_roleentity.Role);
+        });
+        it('resolves to RoleWithCompany when the company feature is enabled', ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(_rolewithcompanyentity.RoleWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        it('creates a plain entity without companyId when the company feature is disabled', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            await service.ensureDataSourceRepository();
+            mockRepo.create.mockReturnValue({});
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'Manager'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.companyId).toBeUndefined();
+        });
+        it('stamps companyId from the DTO on create when the company feature is enabled', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            await service.ensureDataSourceRepository();
+            mockRepo.create.mockReturnValue({});
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'Manager',
+                companyId: 'company-explicit'
+            }, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-from-user'
+            }));
+            expect(entity.companyId).toBe('company-explicit');
+        });
+        it('falls back to the user companyId on create when the DTO omits it', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            await service.ensureDataSourceRepository();
+            mockRepo.create.mockReturnValue({});
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'Manager'
+            }, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-from-user'
+            }));
+            expect(entity.companyId).toBe('company-from-user');
+        });
+        it('does not override companyId on update when the DTO omits it', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            await service.ensureDataSourceRepository();
+            const existing = buildRole({
+                id: 'role-uuid-1',
+                companyId: 'existing-company'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'role-uuid-1',
+                name: 'Manager Updated'
+            }, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-from-user'
+            }));
+            expect(entity.companyId).toBe('existing-company');
+        });
+        it('overrides companyId on update when explicitly provided in the DTO', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            await service.ensureDataSourceRepository();
+            const existing = buildRole({
+                id: 'role-uuid-1',
+                companyId: 'existing-company'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'role-uuid-1',
+                name: 'Manager Updated',
+                companyId: 'new-company'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.companyId).toBe('new-company');
+        });
+        it('throws NotFoundException when updating a role that does not exist', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            await service.ensureDataSourceRepository();
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.convertSingleDtoToEntity({
+                id: 'missing-role'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('selects the default field set without companyId when the company feature is disabled', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const query = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
+            expect(query.select).toHaveBeenCalledWith(expect.not.arrayContaining([
+                'role.companyId'
+            ]));
+        });
+        it('includes companyId in the default field set when the company feature is enabled', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
+            expect(query.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'role.companyId'
+            ]));
+        });
+        it('uses the explicitly provided select list as-is', async ()=>{
+            const query = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)(), [
+                'id',
+                'name'
+            ]);
+            expect(query.select).toHaveBeenCalledWith([
+                'role.id',
+                'role.name'
+            ]);
+        });
+    });
+    describe('getGlobalSearchQuery', ()=>{
+        it('filters by name or description', async ()=>{
+            const query = mockRepo.createQueryBuilder();
+            await service.getGlobalSearchQuery(query, 'manager');
+            expect(query.andWhere).toHaveBeenCalledWith('(role.name LIKE :search OR role.description LIKE :search)', {
+                search: '%manager%'
+            });
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies a company filter clause when the company feature is enabled and the user has a company', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(query, {}, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            }));
+            expect(query.andWhere).toHaveBeenCalledWith('role.companyId = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('does not apply a company filter when the company feature is disabled', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const query = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(query, {}, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-1'
+            }));
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+    });
+    describe('convertEntityToResponseDto', ()=>{
+        it('defaults companyId to null when the entity has no companyId field', ()=>{
+            const entity = buildRole();
+            const dto = service.convertEntityToResponseDto(entity, false);
+            expect(dto.companyId).toBeNull();
+        });
+        it('surfaces companyId when present on the entity', ()=>{
+            const entity = buildRole({
+                companyId: 'company-1'
+            });
+            const dto = service.convertEntityToResponseDto(entity, false);
+            expect(dto.companyId).toBe('company-1');
+        });
+    });
+    describe('beforeDeleteOperation', ()=>{
+        function buildQueryRunner(permissionRepo) {
+            return {
+                manager: {
+                    getRepository: jest.fn().mockReturnValue(permissionRepo)
+                }
+            };
+        }
+        it('does nothing when the delete DTO has no ids', async ()=>{
+            const permissionRepo = (0, _repositorymock.createMockRepository)();
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: [],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)(), queryRunner);
+            expect(permissionRepo.find).not.toHaveBeenCalled();
+        });
+        it('cascades ROLE_ACTION and USER_ROLE cleanup and invalidates affected users cache', async ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const permissionRepo = (0, _repositorymock.createMockRepository)();
+            permissionRepo.find.mockResolvedValue([
+                {
+                    userId: 'user-1'
+                },
+                {
+                    userId: 'user-2'
+                },
+                {
+                    userId: null
+                }
+            ]);
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: 'role-uuid-1',
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)(), queryRunner);
+            expect(permissionRepo.delete).toHaveBeenCalledWith(expect.objectContaining({
+                permissionType: 'role_action',
+                sourceType: 'role'
+            }));
+            expect(permissionRepo.delete).toHaveBeenCalledWith(expect.objectContaining({
+                permissionType: 'user_role',
+                targetType: 'role'
+            }));
+            expect(mockPermissionCacheService.invalidateUsers).toHaveBeenCalledWith([
+                'user-1',
+                'user-2'
+            ]);
+        });
+        it('does not invalidate any cache when no users are affected', async ()=>{
+            const permissionRepo = (0, _repositorymock.createMockRepository)();
+            permissionRepo.find.mockResolvedValue([]);
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: [
+                    'role-uuid-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)(), queryRunner);
+            expect(mockPermissionCacheService.invalidateUsers).not.toHaveBeenCalled();
+        });
+        it('supports array ids and dedupes affected user ids', async ()=>{
+            const permissionRepo = (0, _repositorymock.createMockRepository)();
+            permissionRepo.find.mockResolvedValue([
+                {
+                    userId: 'user-1'
+                },
+                {
+                    userId: 'user-1'
+                }
+            ]);
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: [
+                    'role-uuid-1',
+                    'role-uuid-2'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)(), queryRunner);
+            expect(mockPermissionCacheService.invalidateUsers).toHaveBeenCalledWith([
+                'user-1'
+            ]);
+        });
+    });
+});

package/fesm/controllers/action.controller.spec.js

@@ -0,0 +1,75 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { ActionController } from './action.controller';
+describe('ActionController', ()=>{
+    let controller;
+    let mockActionService;
+    let mockIamConfigService;
+    beforeEach(()=>{
+        mockActionService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            getActionsForPermission: jest.fn(),
+            getActionTree: jest.fn()
+        };
+        mockIamConfigService = {};
+        controller = new ActionController(mockActionService, mockIamConfigService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.actionService).toBe(mockActionService);
+        expect(controller.service).toBe(mockActionService);
+    });
+    describe('getActionsForPermission', ()=>{
+        it('returns actions scoped to the caller session company when no companyId is given', async ()=>{
+            const user = buildMockUser();
+            mockActionService.getActionsForPermission.mockResolvedValue([
+                {
+                    id: 'action-1',
+                    code: 'user.create'
+                }
+            ]);
+            const result = await controller.getActionsForPermission({}, user);
+            expect(mockActionService.getActionsForPermission).toHaveBeenCalledWith(user, undefined);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual([
+                {
+                    id: 'action-1',
+                    code: 'user.create'
+                }
+            ]);
+        });
+        it('forwards an explicit companyId override', async ()=>{
+            const user = buildMockUser();
+            mockActionService.getActionsForPermission.mockResolvedValue([]);
+            await controller.getActionsForPermission({
+                companyId: 'company-2'
+            }, user);
+            expect(mockActionService.getActionsForPermission).toHaveBeenCalledWith(user, 'company-2');
+        });
+    });
+    describe('getActionTree', ()=>{
+        it('returns the hierarchical action tree with query filters applied', async ()=>{
+            const user = buildMockUser();
+            mockActionService.getActionTree.mockResolvedValue([
+                {
+                    id: 'action-1',
+                    children: []
+                }
+            ]);
+            const result = await controller.getActionTree({
+                search: 'user',
+                isActive: true,
+                withDeleted: false
+            }, user);
+            expect(mockActionService.getActionTree).toHaveBeenCalledWith(user, 'user', true, false);
+            expect(result.data).toEqual([
+                {
+                    id: 'action-1',
+                    children: []
+                }
+            ]);
+        });
+    });
+});

package/fesm/controllers/company-action-permission.controller.spec.js

@@ -0,0 +1,61 @@
+import { CompanyActionPermissionController } from './company-action-permission.controller';
+describe('CompanyActionPermissionController', ()=>{
+    let controller;
+    let mockPermissionService;
+    beforeEach(()=>{
+        mockPermissionService = {
+            assignCompanyActions: jest.fn(),
+            getCompanyActions: jest.fn()
+        };
+        controller = new CompanyActionPermissionController(mockPermissionService);
+    });
+    describe('assignCompanyActions', ()=>{
+        it('whitelists actions for a company', async ()=>{
+            mockPermissionService.assignCompanyActions.mockResolvedValue({
+                added: 3,
+                removed: 0,
+                total: 3
+            });
+            const result = await controller.assignCompanyActions({
+                companyId: 'company-1',
+                actionIds: [
+                    'action-1',
+                    'action-2',
+                    'action-3'
+                ]
+            });
+            expect(mockPermissionService.assignCompanyActions).toHaveBeenCalledWith({
+                companyId: 'company-1',
+                actionIds: [
+                    'action-1',
+                    'action-2',
+                    'action-3'
+                ]
+            });
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                added: 3,
+                removed: 0,
+                total: 3
+            });
+        });
+    });
+    describe('getCompanyActions', ()=>{
+        it('returns the whitelisted actions for a company', async ()=>{
+            mockPermissionService.getCompanyActions.mockResolvedValue([
+                {
+                    actionId: 'action-1'
+                }
+            ]);
+            const result = await controller.getCompanyActions({
+                companyId: 'company-1'
+            });
+            expect(mockPermissionService.getCompanyActions).toHaveBeenCalledWith('company-1');
+            expect(result.data).toEqual([
+                {
+                    actionId: 'action-1'
+                }
+            ]);
+        });
+    });
+});

package/fesm/controllers/my-permission.controller.spec.js

@@ -0,0 +1,52 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { MyPermissionController } from './my-permission.controller';
+describe('MyPermissionController', ()=>{
+    let controller;
+    let mockPermissionService;
+    beforeEach(()=>{
+        mockPermissionService = {
+            getMyPermissions: jest.fn()
+        };
+        controller = new MyPermissionController(mockPermissionService);
+    });
+    describe('getMyPermissions', ()=>{
+        it('resolves permissions for the current user, branch, and company', async ()=>{
+            const user = buildMockUser({
+                id: 'user-1',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            });
+            const permissions = {
+                menus: [],
+                actions: [
+                    'user.create'
+                ]
+            };
+            mockPermissionService.getMyPermissions.mockResolvedValue(permissions);
+            const result = await controller.getMyPermissions({
+                parentCodes: [
+                    'user'
+                ]
+            }, user);
+            expect(mockPermissionService.getMyPermissions).toHaveBeenCalledWith('user-1', 'branch-1', 'company-1', [
+                'user'
+            ]);
+            expect(result).toEqual({
+                success: true,
+                message: 'Permissions loaded successfully',
+                messageKey: expect.any(String),
+                data: permissions
+            });
+        });
+        it('passes null for missing branch and company context', async ()=>{
+            const user = buildMockUser({
+                id: 'user-1',
+                companyId: undefined,
+                branchId: undefined
+            });
+            mockPermissionService.getMyPermissions.mockResolvedValue({});
+            await controller.getMyPermissions({}, user);
+            expect(mockPermissionService.getMyPermissions).toHaveBeenCalledWith('user-1', null, null, undefined);
+        });
+    });
+});

package/fesm/controllers/role-permission.controller.spec.js

@@ -0,0 +1,136 @@
+import { ForbiddenException } from '@nestjs/common';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { RolePermissionController } from './role-permission.controller';
+describe('RolePermissionController', ()=>{
+    let controller;
+    let mockPermissionService;
+    let mockConfig;
+    beforeEach(()=>{
+        mockPermissionService = {
+            assignRoleActions: jest.fn(),
+            getRoleActions: jest.fn(),
+            assignUserRoles: jest.fn(),
+            getUserRoles: jest.fn()
+        };
+        mockConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        controller = new RolePermissionController(mockPermissionService, mockConfig);
+    });
+    describe('assignRoleActions', ()=>{
+        it('assigns actions to a role and returns the operation summary', async ()=>{
+            mockPermissionService.assignRoleActions.mockResolvedValue({
+                added: 2,
+                removed: 1,
+                total: 3
+            });
+            const result = await controller.assignRoleActions({
+                roleId: 'role-1',
+                actionIds: [
+                    'action-1',
+                    'action-2'
+                ]
+            });
+            expect(mockPermissionService.assignRoleActions).toHaveBeenCalledWith({
+                roleId: 'role-1',
+                actionIds: [
+                    'action-1',
+                    'action-2'
+                ]
+            });
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                added: 2,
+                removed: 1,
+                total: 3
+            });
+        });
+    });
+    describe('getRoleActions', ()=>{
+        it('returns actions assigned to the role', async ()=>{
+            mockPermissionService.getRoleActions.mockResolvedValue([
+                {
+                    actionId: 'action-1'
+                }
+            ]);
+            const result = await controller.getRoleActions({
+                roleId: 'role-1'
+            });
+            expect(mockPermissionService.getRoleActions).toHaveBeenCalledWith('role-1');
+            expect(result.data).toEqual([
+                {
+                    actionId: 'action-1'
+                }
+            ]);
+        });
+    });
+    describe('assignUserRoles', ()=>{
+        it('assigns roles to a user when the caller has access to the target company', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            mockPermissionService.assignUserRoles.mockResolvedValue({
+                added: 1,
+                removed: 0,
+                total: 1
+            });
+            const result = await controller.assignUserRoles({
+                userId: 'user-2',
+                roleIds: [
+                    'role-1'
+                ],
+                companyId: 'company-1'
+            }, user);
+            expect(mockPermissionService.assignUserRoles).toHaveBeenCalledWith({
+                userId: 'user-2',
+                roleIds: [
+                    'role-1'
+                ],
+                companyId: 'company-1'
+            });
+            expect(result.data).toEqual({
+                added: 1,
+                removed: 0,
+                total: 1
+            });
+        });
+        it('rejects assignment when the caller has no access to the target company', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            await expect(controller.assignUserRoles({
+                userId: 'user-2',
+                roleIds: [
+                    'role-1'
+                ],
+                companyId: 'company-2'
+            }, user)).rejects.toThrow(ForbiddenException);
+            expect(mockPermissionService.assignUserRoles).not.toHaveBeenCalled();
+        });
+    });
+    describe('getUserRoles', ()=>{
+        it('returns roles assigned to the user scoped by branch and company', async ()=>{
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            mockPermissionService.getUserRoles.mockResolvedValue([
+                {
+                    roleId: 'role-1'
+                }
+            ]);
+            const result = await controller.getUserRoles({
+                userId: 'user-2',
+                branchId: 'branch-1',
+                companyId: 'company-1'
+            }, user);
+            expect(mockPermissionService.getUserRoles).toHaveBeenCalledWith('user-2', 'branch-1', 'company-1');
+            expect(result.data).toEqual([
+                {
+                    roleId: 'role-1'
+                }
+            ]);
+        });
+    });
+});