@flusys/nestjs-iam 6.0.2 → 6.1.1

package/fesm/services/iam-config.service.spec.js

@@ -0,0 +1,106 @@
+import { IAMPermissionMode } from '../enums/permission-type.enum';
+import { IAMConfigService } from './iam-config.service';
+describe('IAMConfigService', ()=>{
+    describe('with no injected options (defaults)', ()=>{
+        let service;
+        beforeEach(()=>{
+            service = new IAMConfigService();
+        });
+        it('defaults to single database mode', ()=>{
+            expect(service.getDatabaseMode()).toBe('single');
+            expect(service.isMultiTenant()).toBe(false);
+        });
+        it('defaults company feature to disabled', ()=>{
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults permission mode to FULL', ()=>{
+            expect(service.getPermissionMode()).toBe(IAMPermissionMode.FULL);
+            expect(service.isRbacEnabled()).toBe(true);
+            expect(service.isDirectPermissionEnabled()).toBe(true);
+        });
+        it('returns the fallback options object from getOptions', ()=>{
+            expect(service.getOptions()).toEqual({
+                global: false,
+                includeController: false
+            });
+        });
+    });
+    describe('with injected options', ()=>{
+        function buildService(overrides) {
+            const options = {
+                global: false,
+                includeController: false,
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false,
+                    ...overrides
+                }
+            };
+            return new IAMConfigService(options);
+        }
+        it('reports multi-tenant mode when configured', ()=>{
+            const service = buildService({
+                databaseMode: 'multi-tenant'
+            });
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('reports company feature enabled when configured', ()=>{
+            const service = buildService({
+                enableCompanyFeature: true
+            });
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        describe('permission mode: RBAC', ()=>{
+            let service;
+            beforeEach(()=>{
+                service = buildService({
+                    permissionMode: 'RBAC'
+                });
+            });
+            it('enables RBAC but not direct permissions', ()=>{
+                expect(service.getPermissionMode()).toBe(IAMPermissionMode.RBAC);
+                expect(service.isRbacEnabled()).toBe(true);
+                expect(service.isDirectPermissionEnabled()).toBe(false);
+            });
+        });
+        describe('permission mode: DIRECT', ()=>{
+            let service;
+            beforeEach(()=>{
+                service = buildService({
+                    permissionMode: 'DIRECT'
+                });
+            });
+            it('enables direct permissions but not RBAC', ()=>{
+                expect(service.getPermissionMode()).toBe(IAMPermissionMode.DIRECT);
+                expect(service.isRbacEnabled()).toBe(false);
+                expect(service.isDirectPermissionEnabled()).toBe(true);
+            });
+        });
+        describe('permission mode: FULL', ()=>{
+            let service;
+            beforeEach(()=>{
+                service = buildService({
+                    permissionMode: 'FULL'
+                });
+            });
+            it('enables both RBAC and direct permissions', ()=>{
+                expect(service.getPermissionMode()).toBe(IAMPermissionMode.FULL);
+                expect(service.isRbacEnabled()).toBe(true);
+                expect(service.isDirectPermissionEnabled()).toBe(true);
+            });
+        });
+        it('returns the exact injected options object from getOptions', ()=>{
+            const options = {
+                global: true,
+                includeController: true,
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            };
+            const service = new IAMConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

package/fesm/services/iam-datasource.service.spec.js

@@ -0,0 +1,113 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Action } from '../entities/action.entity';
+import { UserIamPermission } from '../entities/user-iam-permission.entity';
+import { UserIamPermissionWithCompany } from '../entities/permission-with-company.entity';
+import { Role } from '../entities/role.entity';
+import { RoleWithCompany } from '../entities/role-with-company.entity';
+import { IAMDataSourceService } from './iam-datasource.service';
+describe('IAMDataSourceService', ()=>{
+    let mockConfigService;
+    beforeEach(()=>{
+        mockConfigService = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
+            getPermissionMode: jest.fn(),
+            getOptions: jest.fn().mockReturnValue({
+                global: false,
+                includeController: false
+            })
+        };
+    });
+    function buildService(request) {
+        return new IAMDataSourceService(mockConfigService, request);
+    }
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('uses the tenant override when defined (true)', ()=>{
+            const service = buildService();
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            expect(service.getEnableCompanyFeatureForTenant({
+                enableCompanyFeature: true
+            })).toBe(true);
+        });
+        it('uses the tenant override when defined (false)', ()=>{
+            const service = buildService();
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.getEnableCompanyFeatureForTenant({
+                enableCompanyFeature: false
+            })).toBe(false);
+        });
+        it('falls back to the config service when the tenant has no override', ()=>{
+            const service = buildService();
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.getEnableCompanyFeatureForTenant({})).toBe(true);
+        });
+        it('falls back to the config service when no tenant is provided', ()=>{
+            const service = buildService();
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.getEnableCompanyFeatureForTenant(undefined)).toBe(true);
+        });
+    });
+    describe('getEnableCompanyFeatureForCurrentTenant', ()=>{
+        it('falls back to the config service when there is no current request/tenant', ()=>{
+            const service = buildService();
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.getEnableCompanyFeatureForCurrentTenant()).toBe(true);
+        });
+    });
+    describe('getIAMEntities', ()=>{
+        it('returns Action + non-company permission + role entities for RBAC mode', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            mockConfigService.getPermissionMode.mockReturnValue(1); // RBAC
+            const service = buildService();
+            const entities = await service.getIAMEntities();
+            expect(entities).toContain(Action);
+            expect(entities).toContain(UserIamPermission);
+            expect(entities).toContain(Role);
+            expect(entities).not.toContain(UserIamPermissionWithCompany);
+            expect(entities).not.toContain(RoleWithCompany);
+        });
+        it('returns company-scoped entities when company feature is enabled', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockConfigService.getPermissionMode.mockReturnValue(3); // FULL
+            const service = buildService();
+            const entities = await service.getIAMEntities();
+            expect(entities).toContain(Action);
+            expect(entities).toContain(UserIamPermissionWithCompany);
+            expect(entities).toContain(RoleWithCompany);
+            expect(entities).not.toContain(UserIamPermission);
+            expect(entities).not.toContain(Role);
+        });
+        it('excludes role entities entirely in DIRECT mode', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            mockConfigService.getPermissionMode.mockReturnValue(2); // DIRECT
+            const service = buildService();
+            const entities = await service.getIAMEntities();
+            expect(entities).toEqual([
+                Action,
+                UserIamPermission
+            ]);
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('resolves IAM entities and delegates to the parent with them', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            mockConfigService.getPermissionMode.mockReturnValue(1); // RBAC
+            const service = buildService();
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const parentSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                host: 'localhost'
+            };
+            const result = await service.createDataSourceFromConfig(config);
+            expect(result).toBe(fakeDataSource);
+            expect(parentSpy).toHaveBeenCalledWith(config, [
+                Action,
+                UserIamPermission,
+                Role
+            ]);
+            parentSpy.mockRestore();
+        });
+    });
+});