@flusys/nestjs-iam 1.1.0-beta → 2.0.0

package/fesm/modules/iam.module.js

@@ -4,17 +4,16 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
+import { PERMISSION_GUARD_CONFIG } from '@flusys/nestjs-shared';
 import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
-import { Module, Scope } from '@nestjs/common';
-import { getRepositoryToken } from '@nestjs/typeorm';
+import { Module } from '@nestjs/common';
 import { IAM_MODULE_OPTIONS } from '../config/iam.constants';
 import { ActionController, CompanyActionPermissionController, MyPermissionController, RoleController, RolePermissionController, UserActionPermissionController } from '../controllers';
-import { Action, Role, RoleWithCompany, UserIamPermission, UserIamPermissionWithCompany } from '../entities';
 import { IAMPermissionMode } from '../enums/permission-type.enum';
-import { PermissionEvaluatorHelper, PermissionModeHelper } from '../helpers';
+import { PermissionModeHelper } from '../helpers';
 import { ActionService, PermissionService, RoleService } from '../services';
 import { IAMConfigService } from '../services/iam-config.service';
-import { IAMDataSourceProvider } from '../services/iam-datasource.provider';
+import { IAMDataSourceService } from '../services/iam-datasource.service';
 import { PermissionCacheService } from '../services/permission-cache.service';
 export class IAMModule {
     static getControllers(permissionMode, enableCompanyFeature) {
@@ -43,33 +42,11 @@ export class IAMModule {
         }
         return baseControllers;
     }
-    static getEntities(permissionMode, enableCompanyFeature) {
-        // Core entities
-        const entities = [];
-        // Action entity - always included
-        entities.push(Action);
-        // Permission entity is always needed
-        if (enableCompanyFeature) {
-            entities.push(UserIamPermissionWithCompany);
-        } else {
-            entities.push(UserIamPermission);
-        }
-        // Role entity - Only for RBAC or FULL mode
-        if (permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL) {
-            if (enableCompanyFeature) {
-                entities.push(RoleWithCompany);
-            } else {
-                entities.push(Role);
-            }
-        }
-        return entities;
-    }
     static getServices(permissionMode) {
         const services = [
             ActionService,
             PermissionService,
-            PermissionCacheService,
-            PermissionEvaluatorHelper
+            PermissionCacheService
         ];
         // RoleService - Only for RBAC or FULL mode
         if (permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL) {
@@ -77,30 +54,32 @@ export class IAMModule {
         }
         return services;
     }
-    /**
-   * Create repository providers that use IAMDataSourceProvider
-   * This replaces TypeOrmModule.forFeature() functionality
-   */ static getRepositoryProviders(permissionMode, enableCompanyFeature) {
-        const entities = this.getEntities(permissionMode, enableCompanyFeature);
-        return entities.map((entity)=>({
-                provide: getRepositoryToken(entity),
-                scope: Scope.REQUEST,
-                useFactory: async (dataSourceProvider)=>{
-                    return await dataSourceProvider.getRepository(entity);
-                },
-                inject: [
-                    IAMDataSourceProvider
-                ]
-            }));
+    static getPermissionGuardConfigProvider(enableCompanyFeature) {
+        return {
+            provide: PERMISSION_GUARD_CONFIG,
+            useValue: {
+                enableCompanyFeature
+            }
+        };
+    }
+    static getExports(permissionMode) {
+        const baseExports = [
+            IAMConfigService,
+            IAMDataSourceService,
+            ActionService,
+            PermissionService,
+            PermissionCacheService,
+            PERMISSION_GUARD_CONFIG
+        ];
+        if (permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL) {
+            baseExports.push(RoleService);
+        }
+        return baseExports;
     }
     static forRoot(options = {}) {
         const { global = false, includeController = false } = options;
-        const databaseMode = options.bootstrapAppConfig?.databaseMode;
         const enableCompanyFeature = options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-        // Read permissionMode from bootstrap config using helper
         const permissionMode = PermissionModeHelper.fromString(options.bootstrapAppConfig?.permissionMode);
-        const isMultiTenant = databaseMode === 'multi-tenant';
-        const entities = this.getEntities(permissionMode, enableCompanyFeature);
         const controllers = includeController ? this.getControllers(permissionMode, enableCompanyFeature) : [];
         const providers = [
             {
@@ -108,83 +87,52 @@ export class IAMModule {
                 useValue: options
             },
             IAMConfigService,
-            IAMDataSourceProvider,
-            ...this.getServices(permissionMode)
-        ];
-        const imports = [
-            CacheModule,
-            UtilsModule
+            IAMDataSourceService,
+            ...this.getServices(permissionMode),
+            this.getPermissionGuardConfigProvider(enableCompanyFeature)
         ];
         const module = {
             module: IAMModule,
-            imports,
+            imports: [
+                CacheModule,
+                UtilsModule
+            ],
             controllers,
             providers,
-            exports: [
-                IAMConfigService,
-                IAMDataSourceProvider,
-                ActionService,
-                PermissionService,
-                PermissionCacheService,
-                PermissionEvaluatorHelper,
-                ...permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL ? [
-                    RoleService
-                ] : []
-            ]
+            exports: this.getExports(permissionMode)
         };
-        if (global) {
-            return {
-                ...module,
-                global: true
-            };
-        }
-        return module;
+        return global ? {
+            ...module,
+            global: true
+        } : module;
     }
     static forRootAsync(asyncOptions) {
         const { global = false, includeController = false, imports: externalImports = [] } = asyncOptions;
-        const databaseMode = asyncOptions.bootstrapAppConfig?.databaseMode;
         const enableCompanyFeature = asyncOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
-        // Read permissionMode from bootstrap config using helper
         const permissionMode = PermissionModeHelper.fromString(asyncOptions.bootstrapAppConfig?.permissionMode);
-        const isMultiTenant = databaseMode === 'multi-tenant';
-        const entities = this.getEntities(permissionMode, enableCompanyFeature);
         const controllers = includeController ? this.getControllers(permissionMode, enableCompanyFeature) : [];
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
         const providers = [
-            ...asyncProviders,
+            ...this.createAsyncProviders(asyncOptions),
             IAMConfigService,
-            IAMDataSourceProvider,
-            ...this.getServices(permissionMode)
-        ];
-        const imports = [
-            ...externalImports,
-            CacheModule,
-            UtilsModule
+            IAMDataSourceService,
+            ...this.getServices(permissionMode),
+            this.getPermissionGuardConfigProvider(enableCompanyFeature)
         ];
         const module = {
             module: IAMModule,
-            imports,
+            imports: [
+                ...externalImports,
+                CacheModule,
+                UtilsModule
+            ],
             controllers,
             providers,
-            exports: [
-                IAMConfigService,
-                IAMDataSourceProvider,
-                ActionService,
-                PermissionService,
-                PermissionCacheService,
-                PermissionEvaluatorHelper,
-                ...permissionMode === IAMPermissionMode.RBAC || permissionMode === IAMPermissionMode.FULL ? [
-                    RoleService
-                ] : []
-            ]
+            exports: this.getExports(permissionMode)
         };
-        if (global) {
-            return {
-                ...module,
-                global: true
-            };
-        }
-        return module;
+        return global ? {
+            ...module,
+            global: true
+        } : module;
     }
     static createAsyncProviders(options) {
         if (options.useExisting || options.useFactory) {

package/fesm/services/action.service.js

@@ -25,13 +25,13 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Scope } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable, Scope } from '@nestjs/common';
 import { In } from 'typeorm';
 import { Action } from '../entities/action.entity';
 import { IAMConfigService } from './iam-config.service';
-import { IAMDataSourceProvider } from './iam-datasource.provider';
+import { IAMDataSourceService } from './iam-datasource.service';
 import { PermissionService } from './permission.service';
 export class ActionService extends RequestScopedApiService {
     resolveEntity() {
@@ -93,55 +93,33 @@ export class ActionService extends RequestScopedApiService {
             deletedById: entity.deletedById
         };
     }
-    // Custom Methods
-    /** Get actions available for permission assignment (filtered by company whitelist) */ async getActionsForPermission(user) {
-        await this.ensureRepositoryInitialized();
+    requireUser(user, methodName) {
         if (!user) {
-            throw new Error('User is required for getActionsForPermission');
+            throw new BadRequestException(`User is required for ${methodName}`);
         }
-        const selectFields = [
-            'id',
-            'code',
-            'name',
-            'description',
-            'actionType',
-            'permissionLogic',
-            'isActive',
-            'parentId',
-            'serial'
-        ];
-        const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user.companyId) {
+    }
+    /** Get actions available for permission assignment (filtered by company whitelist) */ async getActionsForPermission(user) {
+        await this.ensureRepositoryInitialized();
+        this.requireUser(user, 'getActionsForPermission');
+        let whereClause = {};
+        if (this.iamConfigService.isCompanyFeatureEnabled() && user.companyId) {
             const companyActionIds = await this.permissionService.getCompanyActionIds(user.companyId);
             if (companyActionIds.length === 0) {
                 return [];
             }
-            const actions = await this.repository.find({
-                where: {
-                    id: In(companyActionIds)
-                },
-                select: selectFields
-            });
-            return actions.map((action)=>this.convertEntityToResponseDto(action, false));
+            whereClause = {
+                id: In(companyActionIds)
+            };
         }
         const actions = await this.repository.find({
-            select: selectFields
+            where: whereClause,
+            select: this.actionSelectFields
         });
         return actions.map((action)=>this.convertEntityToResponseDto(action, false));
     }
-    /**
-   * Get actions in hierarchical tree structure
-   *
-   * @param user - Logged in user info for company filtering
-   * @param search - Optional search term (name or code)
-   * @param isActive - Optional filter by active status
-   * @param withDeleted - Include deleted actions (default: false)
-   * @returns Array of root actions with nested children
-   */ async getActionTree(user, search, isActive, withDeleted = false) {
+    /** Get actions in hierarchical tree structure */ async getActionTree(user, search, isActive, withDeleted = false) {
         await this.ensureRepositoryInitialized();
-        if (!user) {
-            throw new Error('User is required for getActionTree');
-        }
+        this.requireUser(user, 'getActionTree');
         const query = this.repository.createQueryBuilder('action');
         if (!withDeleted) {
             query.andWhere('action.deletedAt IS NULL');
@@ -189,7 +167,18 @@ export class ActionService extends RequestScopedApiService {
         return rootNodes;
     }
     constructor(cacheManager, utilsService, iamConfigService, dataSourceProvider, permissionService){
-        super('action', null, cacheManager, utilsService, ActionService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "iamConfigService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "permissionService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.iamConfigService = iamConfigService, this.dataSourceProvider = dataSourceProvider, this.permissionService = permissionService;
+        super('action', null, cacheManager, utilsService, ActionService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "iamConfigService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "permissionService", void 0), // Custom Methods
+        _define_property(this, "actionSelectFields", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.iamConfigService = iamConfigService, this.dataSourceProvider = dataSourceProvider, this.permissionService = permissionService, this.actionSelectFields = [
+            'id',
+            'code',
+            'name',
+            'description',
+            'actionType',
+            'permissionLogic',
+            'isActive',
+            'parentId',
+            'serial'
+        ];
     }
 }
 ActionService = _ts_decorate([
@@ -199,14 +188,14 @@ ActionService = _ts_decorate([
     _ts_param(0, Inject('CACHE_INSTANCE')),
     _ts_param(1, Inject(UtilsService)),
     _ts_param(2, Inject(IAMConfigService)),
-    _ts_param(3, Inject(IAMDataSourceProvider)),
+    _ts_param(3, Inject(IAMDataSourceService)),
     _ts_param(4, Inject(PermissionService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof HybridCache === "undefined" ? Object : HybridCache,
         typeof UtilsService === "undefined" ? Object : UtilsService,
         typeof IAMConfigService === "undefined" ? Object : IAMConfigService,
-        typeof IAMDataSourceProvider === "undefined" ? Object : IAMDataSourceProvider,
+        typeof IAMDataSourceService === "undefined" ? Object : IAMDataSourceService,
         typeof PermissionService === "undefined" ? Object : PermissionService
     ])
 ], ActionService);

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

@@ -38,12 +38,9 @@ export class IAMConfigService {
     isMultiTenant() {
         return this.getDatabaseMode() === 'multi-tenant';
     }
-    // Company Feature
-    getEnableCompanyFeature() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
+    // Feature Flags
     isCompanyFeatureEnabled() {
-        return this.getEnableCompanyFeature();
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
     // Permission Mode
     getPermissionMode() {

package/fesm/services/{iam-datasource.provider.js → iam-datasource.service.js}

@@ -29,9 +29,9 @@ import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
 import { Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { Request } from 'express';
-import { IAM_MODULE_OPTIONS } from '../config/iam.constants';
-import { IAMModuleOptions } from '../interfaces/iam-module-options.interface';
-export class IAMDataSourceProvider extends MultiTenantDataSourceService {
+import { PermissionModeHelper } from '../helpers';
+import { IAMConfigService } from './iam-config.service';
+export class IAMDataSourceService extends MultiTenantDataSourceService {
     // Factory Methods
     static buildParentOptions(options) {
         return {
@@ -42,20 +42,17 @@ export class IAMDataSourceProvider extends MultiTenantDataSourceService {
         };
     }
     // Feature Flags
-    getEnableCompanyFeature() {
-        return this.iamOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
     getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.getEnableCompanyFeature();
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
     }
     getEnableCompanyFeatureForCurrentTenant() {
         return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
     }
     // Entity Management
     async getIAMEntities() {
-        const { Action, Role, RoleWithCompany, UserIamPermission, UserIamPermissionWithCompany, getIAMEntitiesByConfig } = await import('../entities');
+        const { getIAMEntitiesByConfig } = await import('../entities');
         const enableCompanyFeature = this.getEnableCompanyFeatureForCurrentTenant();
-        const permissionMode = this.iamOptions.bootstrapAppConfig?.permissionMode || 'FULL';
+        const permissionMode = PermissionModeHelper.toString(this.configService.getPermissionMode());
         return getIAMEntitiesByConfig(enableCompanyFeature, permissionMode);
     }
     // Overrides
@@ -64,9 +61,9 @@ export class IAMDataSourceProvider extends MultiTenantDataSourceService {
         return super.createDataSourceFromConfig(config, entities);
     }
     async getSingleDataSource() {
-        if (!IAMDataSourceProvider.singleDataSource) {
-            if (IAMDataSourceProvider.singleConnectionLock) {
-                return IAMDataSourceProvider.singleConnectionLock;
+        if (!IAMDataSourceService.singleDataSource) {
+            if (IAMDataSourceService.singleConnectionLock) {
+                return IAMDataSourceService.singleConnectionLock;
             }
             const lockPromise = (async ()=>{
                 const config = this.getDefaultDatabaseConfig();
@@ -74,63 +71,63 @@ export class IAMDataSourceProvider extends MultiTenantDataSourceService {
                     throw new Error('Default database config is not available');
                 }
                 const ds = await this.createDataSourceFromConfig(config);
-                IAMDataSourceProvider.singleDataSource = ds;
-                IAMDataSourceProvider.initialized = true;
+                IAMDataSourceService.singleDataSource = ds;
+                IAMDataSourceService.initialized = true;
                 return ds;
             })();
-            IAMDataSourceProvider.singleConnectionLock = lockPromise;
+            IAMDataSourceService.singleConnectionLock = lockPromise;
             try {
                 return await lockPromise;
             } finally{
-                IAMDataSourceProvider.singleConnectionLock = null;
+                IAMDataSourceService.singleConnectionLock = null;
             }
         }
-        return IAMDataSourceProvider.singleDataSource;
+        return IAMDataSourceService.singleDataSource;
     }
     async getOrCreateTenantConnection(tenant) {
         // Return existing initialized connection from IAM-specific cache
-        const existing = IAMDataSourceProvider.tenantConnections.get(tenant.id);
+        const existing = IAMDataSourceService.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) {
             return existing;
         }
         // If another request is creating this tenant's connection, wait for it
-        const pendingConnection = IAMDataSourceProvider.connectionLocks.get(tenant.id);
+        const pendingConnection = IAMDataSourceService.connectionLocks.get(tenant.id);
         if (pendingConnection) {
             return pendingConnection;
         }
         // Create connection with lock to prevent race conditions
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
-        IAMDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        IAMDataSourceService.connectionLocks.set(tenant.id, connectionPromise);
         try {
             const dataSource = await connectionPromise;
-            IAMDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            IAMDataSourceService.tenantConnections.set(tenant.id, dataSource);
             return dataSource;
         } finally{
-            IAMDataSourceProvider.connectionLocks.delete(tenant.id);
+            IAMDataSourceService.connectionLocks.delete(tenant.id);
         }
     }
-    constructor(iamOptions, request){
-        super(IAMDataSourceProvider.buildParentOptions(iamOptions), request), _define_property(this, "iamOptions", void 0), _define_property(this, "logger", void 0), this.iamOptions = iamOptions, this.logger = new Logger(IAMDataSourceProvider.name);
+    constructor(configService, request){
+        super(IAMDataSourceService.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new Logger(IAMDataSourceService.name);
     }
 }
 // Override parent's static properties to have IAM-specific cache
-_define_property(IAMDataSourceProvider, "tenantConnections", new Map());
-_define_property(IAMDataSourceProvider, "singleDataSource", null);
-_define_property(IAMDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(IAMDataSourceProvider, "initialized", false);
-_define_property(IAMDataSourceProvider, "connectionLocks", new Map());
-_define_property(IAMDataSourceProvider, "singleConnectionLock", null);
-IAMDataSourceProvider = _ts_decorate([
+_define_property(IAMDataSourceService, "tenantConnections", new Map());
+_define_property(IAMDataSourceService, "singleDataSource", null);
+_define_property(IAMDataSourceService, "tenantsRegistry", new Map());
+_define_property(IAMDataSourceService, "initialized", false);
+_define_property(IAMDataSourceService, "connectionLocks", new Map());
+_define_property(IAMDataSourceService, "singleConnectionLock", null);
+IAMDataSourceService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST
     }),
-    _ts_param(0, Inject(IAM_MODULE_OPTIONS)),
+    _ts_param(0, Inject(IAMConfigService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(REQUEST)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof IAMModuleOptions === "undefined" ? Object : IAMModuleOptions,
+        typeof IAMConfigService === "undefined" ? Object : IAMConfigService,
         typeof Request === "undefined" ? Object : Request
     ])
-], IAMDataSourceProvider);
+], IAMDataSourceService);

package/fesm/services/index.js

@@ -1,6 +1,6 @@
 export * from './action.service';
 export * from './iam-config.service';
-export * from './iam-datasource.provider';
+export * from './iam-datasource.service';
 export * from './permission-cache.service';
 export * from './permission.service';
 export * from './role.service';