@flusys/nestjs-iam 6.0.1 → 6.1.0

package/fesm/services/role.service.js

@@ -25,15 +25,57 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
 import { Inject, Injectable, Scope } from '@nestjs/common';
+import { In } from 'typeorm';
+import { UserIamPermissionWithCompany } from '../entities/permission-with-company.entity';
 import { RoleWithCompany } from '../entities/role-with-company.entity';
 import { Role } from '../entities/role.entity';
+import { UserIamPermission } from '../entities/user-iam-permission.entity';
+import { IamEntityType } from '../enums/iam-entity-type.enum';
+import { IamPermissionType } from '../enums/iam-permission-type.enum';
 import { IAMConfigService } from './iam-config.service';
 import { IAMDataSourceService } from './iam-datasource.service';
+import { PermissionCacheService } from './permission-cache.service';
 export class RoleService extends ApiService {
+    async beforeDeleteOperation(dto, user, queryRunner) {
+        await super.beforeDeleteOperation(dto, user, queryRunner);
+        const roleIds = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        if (roleIds.length === 0) {
+            return;
+        }
+        const enableCompanyFeature = this.iamConfigService.isCompanyFeatureEnabled();
+        const permissionEntity = enableCompanyFeature ? UserIamPermissionWithCompany : UserIamPermission;
+        const permissionRepo = queryRunner.manager.getRepository(permissionEntity);
+        const userRoleRows = await permissionRepo.find({
+            where: {
+                permissionType: IamPermissionType.USER_ROLE,
+                sourceType: IamEntityType.USER,
+                targetType: IamEntityType.ROLE,
+                targetId: In(roleIds)
+            }
+        });
+        const affectedUserIds = [
+            ...new Set(userRoleRows.map((row)=>row.userId).filter((id)=>!!id))
+        ];
+        await permissionRepo.delete({
+            permissionType: IamPermissionType.ROLE_ACTION,
+            sourceType: IamEntityType.ROLE,
+            sourceId: In(roleIds)
+        });
+        await permissionRepo.delete({
+            permissionType: IamPermissionType.USER_ROLE,
+            targetType: IamEntityType.ROLE,
+            targetId: In(roleIds)
+        });
+        if (affectedUserIds.length > 0) {
+            await this.permissionCacheService.invalidateUsers(affectedUserIds);
+        }
+    }
     resolveEntity() {
         return this.iamConfigService.isCompanyFeatureEnabled() ? RoleWithCompany : Role;
     }
@@ -107,8 +149,8 @@ export class RoleService extends ApiService {
             deletedById: entity.deletedById
         };
     }
-    constructor(cacheManager, utilsService, iamConfigService, dataSourceProvider){
-        super('role', cacheManager, utilsService, RoleService.name, true, 'iam', undefined, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "iamConfigService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.iamConfigService = iamConfigService;
+    constructor(cacheManager, utilsService, iamConfigService, dataSourceProvider, permissionCacheService){
+        super('role', cacheManager, utilsService, RoleService.name, true, 'iam', undefined, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "iamConfigService", void 0), _define_property(this, "permissionCacheService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.iamConfigService = iamConfigService, this.permissionCacheService = permissionCacheService;
     }
 }
 RoleService = _ts_decorate([
@@ -119,11 +161,13 @@ RoleService = _ts_decorate([
     _ts_param(1, Inject(UtilsService)),
     _ts_param(2, Inject(IAMConfigService)),
     _ts_param(3, Inject(IAMDataSourceService)),
+    _ts_param(4, Inject(PermissionCacheService)),
     _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 IAMDataSourceService === "undefined" ? Object : IAMDataSourceService
+        typeof IAMDataSourceService === "undefined" ? Object : IAMDataSourceService,
+        typeof PermissionCacheService === "undefined" ? Object : PermissionCacheService
     ])
 ], RoleService);

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

@@ -0,0 +1,308 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { Role } from '../entities/role.entity';
+import { RoleWithCompany } from '../entities/role-with-company.entity';
+import { IAMConfigService } from './iam-config.service';
+import { IAMDataSourceService } from './iam-datasource.service';
+import { PermissionCacheService } from './permission-cache.service';
+import { RoleService } from './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 = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockIamConfigService = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockPermissionCacheService = {
+            invalidateUsers: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                RoleService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: IAMConfigService,
+                    useValue: mockIamConfigService
+                },
+                {
+                    provide: IAMDataSourceService,
+                    useValue: mockDataSourceProvider
+                },
+                {
+                    provide: PermissionCacheService,
+                    useValue: mockPermissionCacheService
+                }
+            ]
+        }).compile();
+        service = await module.resolve(RoleService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to Role when the company feature is disabled', ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(false);
+            expect(service.resolveEntity()).toBe(Role);
+        });
+        it('resolves to RoleWithCompany when the company feature is enabled', ()=>{
+            mockIamConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(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'
+            }, 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'
+            }, 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'
+            }, 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'
+            }, 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'
+            }, 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'
+            }, 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, 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, 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, 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, {}, 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, {}, 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 = createMockRepository();
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: [],
+                type: 'delete'
+            }, 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 = 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'
+            }, 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 = createMockRepository();
+            permissionRepo.find.mockResolvedValue([]);
+            const queryRunner = buildQueryRunner(permissionRepo);
+            await service.beforeDeleteOperation({
+                id: [
+                    'role-uuid-1'
+                ],
+                type: 'delete'
+            }, buildMockUser(), queryRunner);
+            expect(mockPermissionCacheService.invalidateUsers).not.toHaveBeenCalled();
+        });
+        it('supports array ids and dedupes affected user ids', async ()=>{
+            const permissionRepo = 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'
+            }, buildMockUser(), queryRunner);
+            expect(mockPermissionCacheService.invalidateUsers).toHaveBeenCalledWith([
+                'user-1'
+            ]);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-iam",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "Identity and Access Management (IAM) module for NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -90,7 +90,7 @@
     "express": "^5.0.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.0.1",
-    "@flusys/nestjs-shared": "6.0.1"
+    "@flusys/nestjs-core": "6.1.0",
+    "@flusys/nestjs-shared": "6.1.0"
   }
 }

package/services/action.service.d.ts

@@ -1,19 +1,23 @@
 import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { SelectQueryBuilder } from 'typeorm';
+import { QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { CreateActionDto, UpdateActionDto } from '../dtos/action.dto';
 import { Action } from '../entities/action.entity';
 import { IAction, IActionTree } from '../interfaces/action.interface';
 import { IAMConfigService } from './iam-config.service';
 import { IAMDataSourceService } from './iam-datasource.service';
+import { PermissionCacheService } from './permission-cache.service';
 import { PermissionService } from './permission.service';
 export declare class ActionService extends ApiService<CreateActionDto, UpdateActionDto, IAction, Action> {
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     private readonly iamConfigService;
     private readonly permissionService;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceService, permissionService: PermissionService);
+    private readonly permissionCacheService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceService, permissionService: PermissionService, permissionCacheService: PermissionCacheService);
+    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, queryRunner: QueryRunner): Promise<void>;
     getSelectQuery(query: SelectQueryBuilder<Action>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
         query: SelectQueryBuilder<Action>;
         isRaw: boolean;
@@ -25,7 +29,7 @@ export declare class ActionService extends ApiService<CreateActionDto, UpdateAct
     protected convertEntityToResponseDto(entity: Action, _isRaw: boolean): IAction;
     private readonly actionSelectFields;
     private requireUser;
-    getActionsForPermission(user: ILoggedUserInfo): Promise<IAction[]>;
+    getActionsForPermission(user: ILoggedUserInfo, companyId?: string): Promise<IAction[]>;
     getActionTree(user: ILoggedUserInfo, search?: string, isActive?: boolean, withDeleted?: boolean): Promise<IActionTree[]>;
     private buildActionTree;
 }

package/services/permission-cache.service.d.ts

@@ -1,10 +1,5 @@
-import { HybridCache } from '@flusys/nestjs-shared';
-export interface PermissionCacheKeyOptions {
-    userId: string;
-    companyId?: string | null;
-    branchId?: string | null;
-    enableCompanyFeature: boolean;
-}
+import { HybridCache, PermissionCacheKeyOptions, PermissionGuardConfig } from '@flusys/nestjs-shared';
+export { PermissionCacheKeyOptions } from '@flusys/nestjs-shared';
 export interface CachedMyPermissions {
     frontendActions: Array<{
         id: string;
@@ -15,24 +10,23 @@ export interface CachedMyPermissions {
     }>;
     backendCodes: string[];
 }
+export declare const MY_PERMISSIONS_CACHE_PREFIX = "my-permissions";
 export declare class PermissionCacheService {
     private readonly cacheManager;
+    private readonly guardConfig?;
+    private readonly TRACKED_KEYS_PREFIX;
+    private readonly TRACKED_SCOPES_PREFIX;
     private readonly TTL;
-    private readonly ACTION_CODE_TTL;
-    private readonly CACHE_PREFIX;
-    private readonly MY_PERMISSIONS_PREFIX;
-    private readonly ACTION_CODE_PREFIX;
-    constructor(cacheManager: HybridCache);
-    generateCacheKey(options: PermissionCacheKeyOptions): string;
-    generateMyPermissionsCacheKey(options: PermissionCacheKeyOptions): string;
+    constructor(cacheManager: HybridCache, guardConfig?: PermissionGuardConfig | undefined);
+    private parseDurationMs;
     private buildCacheKey;
-    setPermissions(options: PermissionCacheKeyOptions, permissions: string[]): Promise<void>;
+    private scopeToken;
+    private buildTrackedKeysKey;
+    private buildTrackedScopesKey;
     setMyPermissions(options: PermissionCacheKeyOptions, data: CachedMyPermissions): Promise<void>;
     getMyPermissions(options: PermissionCacheKeyOptions): Promise<CachedMyPermissions | null>;
-    private generateActionCodeCacheKey;
-    setActionCodeMap(codeToIdMap: Record<string, string>, tenantId?: string): Promise<void>;
-    getActionIdsByCodes(codes: string[], tenantId?: string): Promise<Record<string, string> | null>;
+    private trackKey;
     invalidateUser(userId: string, companyId?: string | null, branchIds?: (string | null)[]): Promise<void>;
+    private invalidateScope;
     invalidateUsers(userIds: string[], companyId?: string | null, branchIds?: (string | null)[]): Promise<number>;
-    invalidateRole(_roleId: string, userIds: string[], companyId?: string | null, branchIds?: (string | null)[]): Promise<number>;
 }

package/services/permission.service.d.ts

@@ -10,6 +10,7 @@ export declare class PermissionService {
     private getPermissionRepository;
     private getActionRepository;
     private getRoleRepository;
+    private getActionsMap;
     assignUserActions(dto: AssignUserActionsDto): Promise<PermissionOperationResultDto>;
     getUserActions(userId: string, branchId: string | undefined, companyId?: string | undefined): Promise<UserActionResponseDto[]>;
     assignRoleActions(dto: AssignRoleActionsDto): Promise<PermissionOperationResultDto>;
@@ -23,7 +24,6 @@ export declare class PermissionService {
     getUserRoles(userId: string, branchId?: string | undefined, companyId?: string | undefined): Promise<UserRoleResponseDto[]>;
     getMyPermissions(userId: string, branchId: string | null, companyId?: string | null, parentCodes?: string[]): Promise<MyPermissionsResponseDto>;
     private buildResponseFromCache;
-    private getCurrentTenantId;
     private getParentIdsByCodesWithCache;
     private fetchAndCachePermissions;
     private collectAllActionIds;
@@ -34,7 +34,10 @@ export declare class PermissionService {
     private getUserRoleIds;
     private getRoleActionIds;
     private getUserActionIds;
-    private invalidateUserPermissionCache;
     private invalidateRoleMembersCache;
-    private invalidateCompanyMembersCache;
+    invalidateCompanyMembersCache(companyId: string): Promise<number>;
+    revokeCompanyPermissions(companyId: string): Promise<void>;
+    revokeBranchPermissions(branchId: string, companyId: string): Promise<void>;
+    revokeUserCompanyAccess(userId: string, companyId: string): Promise<void>;
+    revokeUserBranchAccess(userId: string, branchId: string, companyId: string): Promise<void>;
 }

package/services/role.service.d.ts

@@ -1,17 +1,21 @@
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { EntityTarget, SelectQueryBuilder } from 'typeorm';
+import { EntityTarget, QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { CreateRoleDto, UpdateRoleDto } from '../dtos/role.dto';
 import { RoleBase } from '../entities/role-base.entity';
 import { IRole } from '../interfaces/role.interface';
 import { IAMConfigService } from './iam-config.service';
 import { IAMDataSourceService } from './iam-datasource.service';
+import { PermissionCacheService } from './permission-cache.service';
 export declare class RoleService extends ApiService<CreateRoleDto, UpdateRoleDto, IRole, RoleBase> {
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     private readonly iamConfigService;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceService);
+    private readonly permissionCacheService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, iamConfigService: IAMConfigService, dataSourceProvider: IAMDataSourceService, permissionCacheService: PermissionCacheService);
+    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, queryRunner: QueryRunner): Promise<void>;
     protected resolveEntity(): EntityTarget<RoleBase>;
     convertSingleDtoToEntity(dto: CreateRoleDto | UpdateRoleDto, user: ILoggedUserInfo | null): Promise<RoleBase>;
     getSelectQuery(query: SelectQueryBuilder<RoleBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{