@flusys/nestjs-iam 1.1.0-beta → 2.0.0

package/cjs/services/action.service.js

@@ -14,7 +14,7 @@ const _common = require("@nestjs/common");
 const _typeorm = require("typeorm");
 const _actionentity = require("../entities/action.entity");
 const _iamconfigservice = require("./iam-config.service");
-const _iamdatasourceprovider = require("./iam-datasource.provider");
+const _iamdatasourceservice = require("./iam-datasource.service");
 const _permissionservice = require("./permission.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -103,55 +103,33 @@ let ActionService = class ActionService extends _classes.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 _common.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: (0, _typeorm.In)(companyActionIds)
-                },
-                select: selectFields
-            });
-            return actions.map((action)=>this.convertEntityToResponseDto(action, false));
+            whereClause = {
+                id: (0, _typeorm.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');
@@ -199,7 +177,18 @@ let ActionService = class ActionService extends _classes.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([
@@ -209,14 +198,14 @@ ActionService = _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_param(4, (0, _common.Inject)(_permissionservice.PermissionService)),
     _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,
         typeof _permissionservice.PermissionService === "undefined" ? Object : _permissionservice.PermissionService
     ])
 ], ActionService);

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

@@ -48,12 +48,9 @@ let IAMConfigService = 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/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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "PermissionCacheService", {
     }
 });
 const _nestjsshared = require("@flusys/nestjs-shared");
+const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -40,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) {
@@ -60,20 +60,11 @@ let PermissionCacheService = 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 = _utils.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 {
@@ -81,7 +72,8 @@ let PermissionCacheService = 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 = _utils.ErrorHandler.getErrorMessage(error);
+            this.logger.error(`Failed to cache my-permissions: ${errorMessage}`);
         }
     }
     async getMyPermissions(options) {
@@ -93,28 +85,35 @@ let PermissionCacheService = class PermissionCacheService {
             }
             return result || null;
         } catch (error) {
-            this.logger.error(`Failed to get my-permissions from cache: ${error}`);
+            const errorMessage = _utils.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 = _utils.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]) {
@@ -123,19 +122,11 @@ let PermissionCacheService = 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 = _utils.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 {
@@ -145,10 +136,7 @@ let PermissionCacheService = 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
                 ];
@@ -156,18 +144,17 @@ let PermissionCacheService = 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 = _utils.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;
@@ -179,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}`);
@@ -197,16 +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) {
-            this.logger.error(`Failed to clear all caches: ${error}`);
-        }
-    }
     constructor(cacheManager){
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "logger", void 0);