@flusys/nestjs-iam 1.0.0-rc → 2.0.0

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

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "IAMDataSourceProvider", {
+Object.defineProperty(exports, "IAMDataSourceService", {
     enumerable: true,
     get: function() {
-        return IAMDataSourceProvider;
+        return IAMDataSourceService;
     }
 });
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _core = require("@nestjs/core");
 const _express = require("express");
-const _iamconstants = require("../config/iam.constants");
-const _iammoduleoptionsinterface = require("../interfaces/iam-module-options.interface");
+const _helpers = require("../helpers");
+const _iamconfigservice = require("./iam-config.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -82,7 +82,7 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-let IAMDataSourceProvider = class IAMDataSourceProvider extends _modules.MultiTenantDataSourceService {
+let IAMDataSourceService = class IAMDataSourceService extends _modules.MultiTenantDataSourceService {
     // Factory Methods
     static buildParentOptions(options) {
         return {
@@ -93,20 +93,17 @@ let IAMDataSourceProvider = class IAMDataSourceProvider extends _modules.MultiTe
         };
     }
     // 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 Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        const { getIAMEntitiesByConfig } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
         const enableCompanyFeature = this.getEnableCompanyFeatureForCurrentTenant();
-        const permissionMode = this.iamOptions.bootstrapAppConfig?.permissionMode || 'FULL';
+        const permissionMode = _helpers.PermissionModeHelper.toString(this.configService.getPermissionMode());
         return getIAMEntitiesByConfig(enableCompanyFeature, permissionMode);
     }
     // Overrides
@@ -115,9 +112,9 @@ let IAMDataSourceProvider = class IAMDataSourceProvider extends _modules.MultiTe
         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();
@@ -125,63 +122,63 @@ let IAMDataSourceProvider = class IAMDataSourceProvider extends _modules.MultiTe
                     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 _common.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 _common.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([
     (0, _common.Injectable)({
         scope: _common.Scope.REQUEST
     }),
-    _ts_param(0, (0, _common.Inject)(_iamconstants.IAM_MODULE_OPTIONS)),
+    _ts_param(0, (0, _common.Inject)(_iamconfigservice.IAMConfigService)),
     _ts_param(1, (0, _common.Optional)()),
     _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _iammoduleoptionsinterface.IAMModuleOptions === "undefined" ? Object : _iammoduleoptionsinterface.IAMModuleOptions,
+        typeof _iamconfigservice.IAMConfigService === "undefined" ? Object : _iamconfigservice.IAMConfigService,
         typeof _express.Request === "undefined" ? Object : _express.Request
     ])
-], IAMDataSourceProvider);
+], IAMDataSourceService);

package/cjs/services/index.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./action.service"), exports);
 _export_star(require("./iam-config.service"), exports);
-_export_star(require("./iam-datasource.provider"), exports);
+_export_star(require("./iam-datasource.service"), exports);
 _export_star(require("./permission-cache.service"), exports);
 _export_star(require("./permission.service"), exports);
 _export_star(require("./role.service"), exports);

package/cjs/services/permission-cache.service.js

@@ -41,18 +41,17 @@ function _ts_param(paramIndex, decorator) {
 let PermissionCacheService = class PermissionCacheService {
     // Cache Key Generation
     generateCacheKey(options) {
-        const { userId, companyId, branchId, enableCompanyFeature } = options;
-        if (enableCompanyFeature && companyId) {
-            return `${this.CACHE_PREFIX}:company:${companyId}:branch:${branchId || 'null'}:user:${userId}`;
-        }
-        return `${this.CACHE_PREFIX}:user:${userId}`;
+        return this.buildCacheKey(this.CACHE_PREFIX, options);
     }
     generateMyPermissionsCacheKey(options) {
+        return this.buildCacheKey(this.MY_PERMISSIONS_PREFIX, options);
+    }
+    buildCacheKey(prefix, options) {
         const { userId, companyId, branchId, enableCompanyFeature } = options;
         if (enableCompanyFeature && companyId) {
-            return `${this.MY_PERMISSIONS_PREFIX}:company:${companyId}:branch:${branchId || 'null'}:user:${userId}`;
+            return `${prefix}:company:${companyId}:branch:${branchId || 'null'}:user:${userId}`;
         }
-        return `${this.MY_PERMISSIONS_PREFIX}:user:${userId}`;
+        return `${prefix}:user:${userId}`;
     }
     // Cache Operations
     async setPermissions(options, permissions) {
@@ -66,17 +65,6 @@ let PermissionCacheService = class PermissionCacheService {
         // Don't throw - cache failure shouldn't break the operation
         }
     }
-    async getPermissions(options) {
-        try {
-            const key = this.generateCacheKey(options);
-            const result = await this.cacheManager.get(key);
-            return result || null;
-        } catch (error) {
-            const errorMessage = _utils.ErrorHandler.getErrorMessage(error);
-            this.logger.error(`Failed to get permissions from cache: ${errorMessage}`);
-            return null;
-        }
-    }
     // My-Permissions Cache Operations
     async setMyPermissions(options, data) {
         try {
@@ -139,16 +127,6 @@ let PermissionCacheService = class PermissionCacheService {
             return null;
         }
     }
-    async invalidateActionCodeCache(tenantId) {
-        try {
-            const key = this.generateActionCodeCacheKey(tenantId);
-            await this.cacheManager.del(key);
-            this.logger.debug(`Invalidated action code cache${tenantId ? ` for tenant ${tenantId}` : ''}`);
-        } catch (error) {
-            const errorMessage = _utils.ErrorHandler.getErrorMessage(error);
-            this.logger.warn(`Failed to invalidate action code cache: ${errorMessage}`);
-        }
-    }
     // Cache Invalidation
     async invalidateUser(userId, companyId, branchIds) {
         try {
@@ -188,13 +166,6 @@ let PermissionCacheService = class PermissionCacheService {
         }
         return successCount;
     }
-    /** Invalidate cache for all users in company (requires userIds via invalidateUsers) */ async invalidateCompany(companyId) {
-        // Note: HybridCache doesn't support pattern matching (keys() method)
-        // Company-wide invalidation requires passing individual user IDs
-        // This is a placeholder that logs a warning
-        this.logger.warn(`invalidateCompany called for ${companyId}, but pattern matching is not supported. ` + `Use invalidateUsers() with specific user IDs instead.`);
-        return 0;
-    }
     async invalidateRole(roleId, userIds, companyId, branchIds) {
         if (userIds.length === 0) {
             this.logger.debug(`No users found for role ${roleId}`);
@@ -206,17 +177,6 @@ let PermissionCacheService = class PermissionCacheService {
         }
         return count;
     }
-    // Administrative Operations
-    /** Clear all permission caches (memory and redis) */ async clearAll() {
-        try {
-            await this.cacheManager.reset(); // Clear memory cache
-            await this.cacheManager.resetL2(); // Clear redis cache
-            this.logger.warn('Cleared all cache entries (memory and redis)');
-        } catch (error) {
-            const errorMessage = _utils.ErrorHandler.getErrorMessage(error);
-            this.logger.error(`Failed to clear all caches: ${errorMessage}`);
-        }
-    }
     constructor(cacheManager){
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "logger", void 0);

package/cjs/services/permission.service.js

@@ -19,7 +19,7 @@ const _useriampermissionentity = require("../entities/user-iam-permission.entity
 const _actiontypeenum = require("../enums/action-type.enum");
 const _permissiontypeenum = require("../enums/permission-type.enum");
 const _iamconfigservice = require("./iam-config.service");
-const _iamdatasourceprovider = require("./iam-datasource.provider");
+const _iamdatasourceservice = require("./iam-datasource.service");
 const _permissioncacheservice = require("./permission-cache.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -72,8 +72,7 @@ let PermissionService = class PermissionService {
         const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
         const branchId = dto.branchId ?? null;
         const companyId = dto.companyId ?? null;
-        const itemsToAdd = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.ADD);
-        const itemsToRemove = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.REMOVE);
+        const { toAdd: itemsToAdd, toRemove: itemsToRemove } = this.splitItemsByAction(dto.items);
         let added = 0;
         let removed = 0;
         if (itemsToAdd.length > 0) {
@@ -107,8 +106,15 @@ let PermissionService = class PermissionService {
                     branchId: enableCompanyFeature ? branchId : null
                 }));
             if (newPermissions.length > 0) {
-                await permissionRepo.save(newPermissions);
-                added = newPermissions.length;
+                try {
+                    await permissionRepo.save(newPermissions);
+                    added = newPermissions.length;
+                } catch (error) {
+                    if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                        throw new _common.ConflictException('Some permissions already exist for this user. Please refresh and try again.');
+                    }
+                    throw error;
+                }
             }
         }
         if (itemsToRemove.length > 0) {
@@ -128,12 +134,7 @@ let PermissionService = class PermissionService {
             removed = result.affected || 0;
         }
         await this.invalidateUserPermissionCache(dto.userId, branchId, companyId);
-        return {
-            success: true,
-            added,
-            removed,
-            message: `Successfully processed ${dto.items.length} items: ${added} added, ${removed} removed`
-        };
+        return this.buildOperationResult(dto.items.length, added, removed);
     }
     async getUserActions(userId, branchId, companyId) {
         const permissionRepo = await this.getPermissionRepository();
@@ -199,8 +200,7 @@ let PermissionService = class PermissionService {
             });
             roleCompanyId = role?.companyId ?? null;
         }
-        const itemsToAdd = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.ADD);
-        const itemsToRemove = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.REMOVE);
+        const { toAdd: itemsToAdd, toRemove: itemsToRemove } = this.splitItemsByAction(dto.items);
         let added = 0;
         let removed = 0;
         if (itemsToAdd.length > 0) {
@@ -229,8 +229,15 @@ let PermissionService = class PermissionService {
                     branchId: null
                 }));
             if (newPermissions.length > 0) {
-                await permissionRepo.save(newPermissions);
-                added = newPermissions.length;
+                try {
+                    await permissionRepo.save(newPermissions);
+                    added = newPermissions.length;
+                } catch (error) {
+                    if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                        throw new _common.ConflictException('Some role-action permissions already exist. Please refresh and try again.');
+                    }
+                    throw error;
+                }
             }
         }
         if (itemsToRemove.length > 0) {
@@ -245,12 +252,7 @@ let PermissionService = class PermissionService {
             removed = result.affected || 0;
         }
         const affectedUsers = await this.invalidateRoleMembersCache(dto.roleId);
-        return {
-            success: true,
-            added,
-            removed,
-            message: `Successfully processed ${dto.items.length} items: ${added} added, ${removed} removed. Invalidated cache for ${affectedUsers} users.`
-        };
+        return this.buildOperationResult(dto.items.length, added, removed, `. Invalidated cache for ${affectedUsers} users.`);
     }
     async getRoleActions(roleId) {
         const permissionRepo = await this.getPermissionRepository();
@@ -292,8 +294,7 @@ let PermissionService = class PermissionService {
     /** Assign or remove actions to/from a company (whitelist) */ async assignCompanyActions(dto) {
         const permissionRepo = await this.getPermissionRepository();
         const dataSource = permissionRepo.manager.connection;
-        const itemsToAdd = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.ADD);
-        const itemsToRemove = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.REMOVE);
+        const { toAdd: itemsToAdd, toRemove: itemsToRemove } = this.splitItemsByAction(dto.items);
         let added = 0;
         let removed = 0;
         let removedRoleActions = 0;
@@ -313,12 +314,7 @@ let PermissionService = class PermissionService {
         });
         const affectedCacheEntries = await this.invalidateCompanyMembersCache(dto.companyId);
         const cascadeInfo = removedRoleActions > 0 || removedUserActions > 0 ? ` Cascaded removal: ${removedRoleActions} role permissions, ${removedUserActions} user permissions.` : '';
-        return {
-            success: true,
-            added,
-            removed,
-            message: `Successfully processed ${dto.items.length} items: ${added} added, ${removed} removed.${cascadeInfo} Invalidated ${affectedCacheEntries} cache entries.`
-        };
+        return this.buildOperationResult(dto.items.length, added, removed, `.${cascadeInfo} Invalidated ${affectedCacheEntries} cache entries.`);
     }
     async addCompanyActions(permissionRepo, companyId, actionIds) {
         const existingPermissions = await permissionRepo.find({
@@ -459,8 +455,7 @@ let PermissionService = class PermissionService {
         const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
         const branchId = dto.branchId ?? null;
         const companyId = dto.companyId ?? null;
-        const itemsToAdd = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.ADD);
-        const itemsToRemove = dto.items.filter((item)=>item.action === _permissiondto.PermissionAction.REMOVE);
+        const { toAdd: itemsToAdd, toRemove: itemsToRemove } = this.splitItemsByAction(dto.items);
         let added = 0;
         let removed = 0;
         if (itemsToAdd.length > 0) {
@@ -494,8 +489,15 @@ let PermissionService = class PermissionService {
                     branchId: enableCompanyFeature ? branchId : null
                 }));
             if (newPermissions.length > 0) {
-                await permissionRepo.save(newPermissions);
-                added = newPermissions.length;
+                try {
+                    await permissionRepo.save(newPermissions);
+                    added = newPermissions.length;
+                } catch (error) {
+                    if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                        throw new _common.ConflictException('Some user-role permissions already exist. Please refresh and try again.');
+                    }
+                    throw error;
+                }
             }
         }
         if (itemsToRemove.length > 0) {
@@ -515,12 +517,7 @@ let PermissionService = class PermissionService {
             removed = result.affected || 0;
         }
         await this.invalidateUserPermissionCache(dto.userId, branchId, companyId);
-        return {
-            success: true,
-            added,
-            removed,
-            message: `Successfully processed ${dto.items.length} items: ${added} added, ${removed} removed`
-        };
+        return this.buildOperationResult(dto.items.length, added, removed);
     }
     /** Get user's roles (branch-scoped, filtered by companyId and branchId if provided) */ async getUserRoles(userId, branchId, companyId) {
         const permissionRepo = await this.getPermissionRepository();
@@ -712,6 +709,20 @@ let PermissionService = class PermissionService {
         return cacheData;
     }
     // Helper Methods
+    /** Split permission items into add and remove arrays */ splitItemsByAction(items) {
+        return {
+            toAdd: items.filter((item)=>item.action === _permissiondto.PermissionAction.ADD),
+            toRemove: items.filter((item)=>item.action === _permissiondto.PermissionAction.REMOVE)
+        };
+    }
+    /** Build standard operation result DTO */ buildOperationResult(totalItems, added, removed, additionalMessage = '') {
+        return {
+            success: true,
+            added,
+            removed,
+            message: `Successfully processed ${totalItems} items: ${added} added, ${removed} removed${additionalMessage}`
+        };
+    }
     /** Get role IDs assigned to a user (merges company-wide + branch-specific roles) */ async getUserRoleIds(userId, branchId, companyId) {
         const permissionRepo = await this.getPermissionRepository();
         const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
@@ -899,11 +910,11 @@ PermissionService = _ts_decorate([
     }),
     _ts_param(0, (0, _common.Inject)(_permissioncacheservice.PermissionCacheService)),
     _ts_param(1, (0, _common.Inject)(_iamconfigservice.IAMConfigService)),
-    _ts_param(2, (0, _common.Inject)(_iamdatasourceprovider.IAMDataSourceProvider)),
+    _ts_param(2, (0, _common.Inject)(_iamdatasourceservice.IAMDataSourceService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _permissioncacheservice.PermissionCacheService === "undefined" ? Object : _permissioncacheservice.PermissionCacheService,
         typeof _iamconfigservice.IAMConfigService === "undefined" ? Object : _iamconfigservice.IAMConfigService,
-        typeof _iamdatasourceprovider.IAMDataSourceProvider === "undefined" ? Object : _iamdatasourceprovider.IAMDataSourceProvider
+        typeof _iamdatasourceservice.IAMDataSourceService === "undefined" ? Object : _iamdatasourceservice.IAMDataSourceService
     ])
 ], PermissionService);

package/cjs/services/role.service.js

@@ -15,7 +15,7 @@ const _common = require("@nestjs/common");
 const _rolewithcompanyentity = require("../entities/role-with-company.entity");
 const _roleentity = require("../entities/role.entity");
 const _iamconfigservice = require("./iam-config.service");
-const _iamdatasourceprovider = require("./iam-datasource.provider");
+const _iamdatasourceservice = require("./iam-datasource.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -132,12 +132,12 @@ RoleService = _ts_decorate([
     _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
     _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
     _ts_param(2, (0, _common.Inject)(_iamconfigservice.IAMConfigService)),
-    _ts_param(3, (0, _common.Inject)(_iamdatasourceprovider.IAMDataSourceProvider)),
+    _ts_param(3, (0, _common.Inject)(_iamdatasourceservice.IAMDataSourceService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
         typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
         typeof _iamconfigservice.IAMConfigService === "undefined" ? Object : _iamconfigservice.IAMConfigService,
-        typeof _iamdatasourceprovider.IAMDataSourceProvider === "undefined" ? Object : _iamdatasourceprovider.IAMDataSourceProvider
+        typeof _iamdatasourceservice.IAMDataSourceService === "undefined" ? Object : _iamdatasourceservice.IAMDataSourceService
     ])
 ], RoleService);

package/controllers/company-action-permission.controller.d.ts

@@ -1,12 +1,9 @@
-import { SingleResponseDto, ILoggedUserInfo } from '@flusys/nestjs-shared';
+import { ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
 import { AssignCompanyActionsDto, CompanyActionResponseDto, GetCompanyActionsDto, PermissionOperationResultDto } from '../dtos/permission.dto';
 import { PermissionService } from '../services/permission.service';
-import { IAMConfigService } from '../services/iam-config.service';
 export declare class CompanyActionPermissionController {
     private readonly permissionService;
-    private readonly config;
-    constructor(permissionService: PermissionService, config: IAMConfigService);
-    private validateCompanyAccess;
+    constructor(permissionService: PermissionService);
     assignCompanyActions(dto: AssignCompanyActionsDto, user: ILoggedUserInfo): Promise<PermissionOperationResultDto>;
     getCompanyActions(dto: GetCompanyActionsDto, user: ILoggedUserInfo): Promise<SingleResponseDto<CompanyActionResponseDto[]>>;
 }

package/controllers/role-permission.controller.d.ts

@@ -6,7 +6,6 @@ export declare class RolePermissionController {
     private readonly permissionService;
     private readonly config;
     constructor(permissionService: PermissionService, config: IAMConfigService);
-    private validateCompanyAccess;
     assignRoleActions(dto: AssignRoleActionsDto): Promise<PermissionOperationResultDto>;
     getRoleActions(dto: GetRoleActionsDto): Promise<SingleResponseDto<RoleActionResponseDto[]>>;
     assignUserRoles(dto: AssignUserRolesDto, user: ILoggedUserInfo): Promise<PermissionOperationResultDto>;

package/controllers/user-action-permission.controller.d.ts

@@ -6,7 +6,6 @@ export declare class UserActionPermissionController {
     private readonly permissionService;
     private readonly config;
     constructor(permissionService: PermissionService, config: IAMConfigService);
-    private validateCompanyAccess;
     assignUserActions(dto: AssignUserActionsDto, user: ILoggedUserInfo): Promise<PermissionOperationResultDto>;
     getUserActions(dto: GetUserActionsDto, user: ILoggedUserInfo): Promise<SingleResponseDto<UserActionResponseDto[]>>;
 }

package/dtos/action.dto.d.ts

@@ -37,10 +37,6 @@ export declare class ActionResponseDto {
 export declare class ActionTreeDto extends ActionResponseDto {
     children: ActionTreeDto[];
 }
-export declare class ActionQueryDto {
-    isActive?: boolean;
-    parentId?: string;
-}
 export declare class ActionTreeQueryDto {
     search?: string;
     isActive?: boolean;

package/dtos/role.dto.d.ts

@@ -10,10 +10,6 @@ declare const UpdateRoleDto_base: import("@nestjs/common").Type<Partial<CreateRo
 export declare class UpdateRoleDto extends UpdateRoleDto_base {
     id: string;
 }
-export declare class RoleQueryDto {
-    companyId?: string;
-    isActive?: boolean;
-}
 export declare class RoleResponseDto {
     id: string;
     readOnly: boolean;

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

@@ -25,26 +25,16 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { JwtAuthGuard, SingleResponseDto, RequirePermission, COMPANY_ACTION_PERMISSIONS, CurrentUser, ILoggedUserInfo } from '@flusys/nestjs-shared';
-import { BadRequestException, Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
+import { COMPANY_ACTION_PERMISSIONS, CurrentUser, ILoggedUserInfo, JwtAuthGuard, RequirePermission, SingleResponseDto } from '@flusys/nestjs-shared';
+import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { AssignCompanyActionsDto, GetCompanyActionsDto, PermissionOperationResultDto } from '../dtos/permission.dto';
 import { PermissionService } from '../services/permission.service';
-import { IAMConfigService } from '../services/iam-config.service';
 export class CompanyActionPermissionController {
-    /** Validates that user can only manage permissions for their own company */ validateCompanyAccess(companyId, user) {
-        if (this.config.isCompanyFeatureEnabled() && user.companyId) {
-            if (companyId !== user.companyId) {
-                throw new BadRequestException('Cannot manage permissions for another company');
-            }
-        }
-    }
     async assignCompanyActions(dto, user) {
-        this.validateCompanyAccess(dto.companyId, user);
         return this.permissionService.assignCompanyActions(dto);
     }
     async getCompanyActions(dto, user) {
-        this.validateCompanyAccess(dto.companyId, user);
         const actions = await this.permissionService.getCompanyActions(dto.companyId);
         return {
             success: true,
@@ -52,12 +42,9 @@ export class CompanyActionPermissionController {
             data: actions
         };
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(permissionService, config){
+    constructor(permissionService){
         _define_property(this, "permissionService", void 0);
-        _define_property(this, "config", void 0);
         this.permissionService = permissionService;
-        this.config = config;
     }
 }
 _ts_decorate([
@@ -112,10 +99,8 @@ CompanyActionPermissionController = _ts_decorate([
     UseGuards(JwtAuthGuard),
     ApiBearerAuth(),
     _ts_param(0, Inject(PermissionService)),
-    _ts_param(1, Inject(IAMConfigService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof PermissionService === "undefined" ? Object : PermissionService,
-        typeof IAMConfigService === "undefined" ? Object : IAMConfigService
+        typeof PermissionService === "undefined" ? Object : PermissionService
     ])
 ], CompanyActionPermissionController);

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

@@ -25,8 +25,7 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { CurrentUser, ILoggedUserInfo } from '@flusys/nestjs-shared';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
+import { CurrentUser, ILoggedUserInfo, JwtAuthGuard } from '@flusys/nestjs-shared';
 import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { MyPermissionsQueryDto, MyPermissionsResponseDto } from '../dtos/permission.dto';

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

@@ -26,19 +26,13 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { JwtAuthGuard, SingleResponseDto, RequirePermission, ROLE_ACTION_PERMISSIONS, USER_ROLE_PERMISSIONS, CurrentUser, ILoggedUserInfo } from '@flusys/nestjs-shared';
-import { BadRequestException, Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
+import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { AssignRoleActionsDto, AssignUserRolesDto, GetRoleActionsDto, GetUserRolesDto, PermissionOperationResultDto } from '../dtos/permission.dto';
+import { validateCompanyAccess } from '../helpers';
 import { PermissionService } from '../services/permission.service';
 import { IAMConfigService } from '../services/iam-config.service';
 export class RolePermissionController {
-    /** Validates that user can only manage permissions within their company */ validateCompanyAccess(companyId, user) {
-        if (this.config.isCompanyFeatureEnabled() && user.companyId && companyId) {
-            if (companyId !== user.companyId) {
-                throw new BadRequestException('Cannot manage permissions for users in another company');
-            }
-        }
-    }
     async assignRoleActions(dto) {
         return this.permissionService.assignRoleActions(dto);
     }
@@ -51,11 +45,11 @@ export class RolePermissionController {
         };
     }
     async assignUserRoles(dto, user) {
-        this.validateCompanyAccess(dto.companyId, user);
+        validateCompanyAccess(this.config, dto.companyId, user, 'Cannot manage permissions for users in another company');
         return this.permissionService.assignUserRoles(dto);
     }
     async getUserRoles(dto, user) {
-        this.validateCompanyAccess(dto.companyId, user);
+        validateCompanyAccess(this.config, dto.companyId, user, 'Cannot manage permissions for users in another company');
         const roles = await this.permissionService.getUserRoles(dto.userId, dto.branchId, dto.companyId);
         return {
             success: true,