@flusys/nestjs-iam 1.1.0-beta → 2.0.0

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

@@ -26,22 +26,22 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { HybridCache } from '@flusys/nestjs-shared';
+import { ErrorHandler } from '@flusys/nestjs-shared/utils';
 import { Inject, Injectable, Logger } from '@nestjs/common';
 export 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) {
@@ -50,20 +50,11 @@ export class PermissionCacheService {
             await this.cacheManager.set(key, permissions, this.TTL);
             this.logger.debug(`Cached ${permissions.length} permissions for key: ${key}`);
         } catch (error) {
-            this.logger.error(`Failed to cache permissions: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to cache permissions: ${errorMessage}`);
         // 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) {
-            this.logger.error(`Failed to get permissions from cache: ${error}`);
-            return null;
-        }
-    }
     // My-Permissions Cache Operations
     async setMyPermissions(options, data) {
         try {
@@ -71,7 +62,8 @@ export class PermissionCacheService {
             await this.cacheManager.set(key, data, this.TTL);
             this.logger.debug(`Cached my-permissions for key: ${key} (${data.frontendActions.length} frontend, ${data.backendCodes.length} backend)`);
         } catch (error) {
-            this.logger.error(`Failed to cache my-permissions: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to cache my-permissions: ${errorMessage}`);
         }
     }
     async getMyPermissions(options) {
@@ -83,28 +75,35 @@ export class PermissionCacheService {
             }
             return result || null;
         } catch (error) {
-            this.logger.error(`Failed to get my-permissions from cache: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to get my-permissions from cache: ${errorMessage}`);
             return null;
         }
     }
-    // Action Code Cache Operations
-    async setActionCodeMap(codeToIdMap) {
+    // Action Code Cache Operations (tenant-aware for multi-tenant mode)
+    /** Generate tenant-aware cache key for action codes */ generateActionCodeCacheKey(tenantId) {
+        if (tenantId) {
+            return `${this.ACTION_CODE_PREFIX}:tenant:${tenantId}:map`;
+        }
+        return `${this.ACTION_CODE_PREFIX}:map`;
+    }
+    async setActionCodeMap(codeToIdMap, tenantId) {
         try {
-            const key = `${this.ACTION_CODE_PREFIX}:map`;
+            const key = this.generateActionCodeCacheKey(tenantId);
             await this.cacheManager.set(key, codeToIdMap, this.ACTION_CODE_TTL);
-            this.logger.debug(`Cached ${Object.keys(codeToIdMap).length} action code mappings`);
+            this.logger.debug(`Cached ${Object.keys(codeToIdMap).length} action code mappings${tenantId ? ` for tenant ${tenantId}` : ''}`);
         } catch (error) {
-            this.logger.error(`Failed to cache action code map: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to cache action code map: ${errorMessage}`);
         }
     }
-    async getActionIdsByCodes(codes) {
+    async getActionIdsByCodes(codes, tenantId) {
         try {
-            const key = `${this.ACTION_CODE_PREFIX}:map`;
+            const key = this.generateActionCodeCacheKey(tenantId);
             const fullMap = await this.cacheManager.get(key);
             if (!fullMap) {
                 return null;
             }
-            // Return only requested codes
             const result = {};
             for (const code of codes){
                 if (fullMap[code]) {
@@ -113,19 +112,11 @@ export class PermissionCacheService {
             }
             return Object.keys(result).length > 0 ? result : null;
         } catch (error) {
-            this.logger.error(`Failed to get action IDs from cache: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to get action IDs from cache: ${errorMessage}`);
             return null;
         }
     }
-    async invalidateActionCodeCache() {
-        try {
-            const key = `${this.ACTION_CODE_PREFIX}:map`;
-            await this.cacheManager.del(key);
-            this.logger.debug('Invalidated action code cache');
-        } catch (error) {
-            this.logger.warn(`Failed to invalidate action code cache: ${error}`);
-        }
-    }
     // Cache Invalidation
     async invalidateUser(userId, companyId, branchIds) {
         try {
@@ -135,10 +126,7 @@ export class PermissionCacheService {
                 // My-permissions cache (full response) - user-based key
                 `${this.MY_PERMISSIONS_PREFIX}:user:${userId}`
             ];
-            // Add company-based keys if companyId provided
             if (companyId) {
-                // If branchIds provided, invalidate all specified branches
-                // Otherwise, invalidate only null branch (company-wide)
                 const branches = branchIds?.length ? branchIds : [
                     null
                 ];
@@ -146,18 +134,17 @@ export class PermissionCacheService {
                     keysToDelete.push(`${this.CACHE_PREFIX}:company:${companyId}:branch:${branchId || 'null'}:user:${userId}`, `${this.MY_PERMISSIONS_PREFIX}:company:${companyId}:branch:${branchId || 'null'}:user:${userId}`);
                 }
             }
-            // Parallel deletion for better performance
             await Promise.all(keysToDelete.map((key)=>this.cacheManager.del(key)));
             this.logger.debug(`Invalidated ${keysToDelete.length} cache keys for user ${userId}`);
         } catch (error) {
-            this.logger.warn(`Failed to invalidate user cache for ${userId}: ${error}`);
+            const errorMessage = ErrorHandler.getErrorMessage(error);
+            this.logger.warn(`Failed to invalidate user cache for ${userId}: ${errorMessage}`);
         }
     }
     async invalidateUsers(userIds, companyId, branchIds) {
         if (userIds.length === 0) {
             return 0;
         }
-        // Parallel invalidation for better performance
         const results = await Promise.allSettled(userIds.map((userId)=>this.invalidateUser(userId, companyId, branchIds)));
         const successCount = results.filter((r)=>r.status === 'fulfilled').length;
         const failedCount = results.filter((r)=>r.status === 'rejected').length;
@@ -169,13 +156,6 @@ export 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}`);
@@ -187,16 +167,6 @@ export 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) {
-            this.logger.error(`Failed to clear all caches: ${error}`);
-        }
-    }
     constructor(cacheManager){
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "logger", void 0);