@vlian/infrastructure 0.9.10

package/dist/cjs/managers/PermissionManager/PermissionManager.js

@@ -0,0 +1,910 @@
+/**
+ * PermissionManager - 权限管理器
+ * 
+ * 提供权限检查、角色检查、权限数据管理等功能
+ * 基于 @vlian/framework 的 StateManager 和 AppEventBus
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PermissionManager", {
+    enumerable: true,
+    get: function() {
+        return PermissionManager;
+    }
+});
+const _types = require("./types");
+const _modules = require("./modules");
+const _configUtils = require("./utils/configUtils");
+const _constants = require("./constants");
+const _PermissionCore = require("./core/PermissionCore");
+const _ConcurrencyController = require("./core/ConcurrencyController");
+const _StateManagerWrapper = require("./core/StateManagerWrapper");
+const _EnvironmentAdapter = require("./runtime/EnvironmentAdapter");
+const _EventManager = require("./observability/EventManager");
+const _PerformanceMonitor = require("./observability/PerformanceMonitor");
+const _LoggingManager = require("./observability/LoggingManager");
+const _MonitoringManager = require("./observability/MonitoringManager");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+let PermissionManager = class PermissionManager {
+    /**
+   * 初始化模块
+   */ initializeModules() {
+        // 初始化日志管理器
+        this.loggingManager = new _LoggingManager.LoggingManager({
+            logger: this.options.logger,
+            enableLogging: this.options.devMode ?? true,
+            context: {
+                instanceId: this.instanceId
+            }
+        });
+        // 初始化监控管理器
+        this.monitoringManager = new _MonitoringManager.MonitoringManager({
+            monitoring: this.options.monitoring,
+            enableMonitoring: true
+        });
+        // 初始化性能监控器
+        this.performanceMonitor = new _PerformanceMonitor.PerformanceMonitor({
+            monitoring: this.options.monitoring,
+            enableDetailedMetrics: this.options.enableDetailedMetrics
+        });
+        // 初始化事件管理器
+        this.eventManager = new _EventManager.EventManager({
+            eventBus: this.options.eventBus,
+            eventNamespace: this.options.eventNamespace,
+            enableEvents: this.options.enableEvents,
+            logger: this.options.logger ? {
+                debug: (...args)=>this.loggingManager.debug(...args),
+                error: (...args)=>this.loggingManager.error(...args)
+            } : undefined,
+            monitoring: {
+                trackEvent: (name, props)=>this.monitoringManager.trackEvent(name, props),
+                captureError: (error, ctx)=>this.monitoringManager.captureError(error, ctx)
+            }
+        });
+        // 初始化状态管理器
+        if (this.options.stateManager) {
+            this.stateManager = new _StateManagerWrapper.StateManagerWrapper({
+                stateManager: this.options.stateManager,
+                logger: {
+                    warn: (...args)=>this.loggingManager.warn(...args),
+                    error: (...args)=>this.loggingManager.error(...args)
+                }
+            });
+        }
+        // 初始化存储管理器
+        this.storageManager = new _modules.StorageManager({
+            stateManager: undefined,
+            storageKey: this.storageKey,
+            environment: this.environment,
+            logger: this.options.logger,
+            monitoring: this.options.monitoring
+        });
+        // 初始化存储
+        if (this.options.storageStrategy === 'state') {
+            this.storageManager.initStorage(this.options.stateManager);
+        }
+        // 初始化加密服务
+        this.encryptionService = new _modules.EncryptionService({
+            enableEncryption: this.options.enableEncryption,
+            encryptionKey: this.options.encryptionKey,
+            encrypt: this.options.encrypt,
+            decrypt: this.options.decrypt,
+            logger: this.options.logger
+        });
+        // 初始化权限检查器
+        this.permissionChecker = new _modules.PermissionChecker({
+            enablePermissionTree: this.options.enablePermissionTree,
+            enableWildcardMatch: this.options.enableWildcardMatch,
+            wildcardMatchMode: this.options.wildcardMatchMode,
+            logWildcardUsage: this.options.logWildcardUsage,
+            permissionTreeConfig: this.options.permissionTreeConfig,
+            allowedWildcardPatterns: this.options.allowedWildcardPatterns,
+            logger: this.options.logger
+        });
+        // 初始化权限数据管理器
+        this.permissionDataManager = new _modules.PermissionDataManager({
+            authManager: this.authManager,
+            permissionExtractor: this.options.permissionExtractor,
+            permissionFetcher: this.options.permissionFetcher,
+            enableCache: this.options.enableCache,
+            logger: this.options.logger,
+            monitoring: this.options.monitoring
+        });
+        // 初始化缓存管理器
+        const extendedOptions = this.options;
+        const cacheSizeLimit = extendedOptions.configGroups?.performance?.cacheSizeLimit;
+        this.permissionCache = new _modules.CacheManager({
+            defaultTTL: this.options.cacheExpiry,
+            maxSize: cacheSizeLimit
+        });
+        this.roleCache = new _modules.CacheManager({
+            defaultTTL: this.options.cacheExpiry,
+            maxSize: cacheSizeLimit
+        });
+        this.permissionDataCache = new _modules.CacheManager({
+            defaultTTL: this.options.cacheExpiry,
+            maxSize: 1
+        });
+        this.permissionTreeCache = new _modules.CacheManager({
+            defaultTTL: this.options.cacheExpiry,
+            maxSize: 1
+        });
+        // 初始化并发控制器
+        this.concurrencyController = new _ConcurrencyController.ConcurrencyController({
+            strategy: this.options.concurrencyStrategy || 'queue',
+            maxQueueSize: this.options.maxQueueSize || 100,
+            operationTimeout: this.options.operationTimeout || 30000
+        });
+        // 初始化权限核心
+        this.permissionCore = new _PermissionCore.PermissionCore({
+            authManager: this.authManager,
+            permissionChecker: this.permissionChecker,
+            permissionDataManager: this.permissionDataManager,
+            concurrencyController: this.concurrencyController,
+            stateManager: this.stateManager,
+            permissionCache: this.permissionCache,
+            roleCache: this.roleCache,
+            permissionDataCache: this.permissionDataCache,
+            permissionTreeCache: this.permissionTreeCache,
+            storageKey: this.storageKey,
+            enableCache: this.options.enableCache
+        });
+        // 初始化运行时层
+        this.environmentAdapter = new _EnvironmentAdapter.EnvironmentAdapter(this.environment);
+        if (this.environmentAdapter.isSupported()) {
+            this.environmentAdapter.init().catch((error)=>{
+                this.loggingManager.warn('Environment adapter init failed:', error);
+            });
+        }
+        // 初始化可选模块
+        if (extendedOptions.rateLimit?.enabled) {
+            this.rateLimiter = new _modules.RateLimiter(extendedOptions.rateLimit);
+        }
+        if (extendedOptions.enableAuditLog !== false) {
+            this.auditLogger = new _modules.AuditLogger({
+                maxSize: extendedOptions.auditLogMaxSize,
+                logger: this.options.logger
+            });
+        }
+        if (extendedOptions.enableChangeHistory !== false) {
+            this.changeHistory = new _modules.ChangeHistory({
+                maxSize: extendedOptions.changeHistoryMaxSize
+            });
+        }
+        if (extendedOptions.checkStrategies) {
+            this._strategyManager = new _modules.StrategyManager(this.permissionChecker, extendedOptions.checkStrategies);
+        }
+        if (extendedOptions.middlewares) {
+            this.middlewareManager = new _modules.MiddlewareManager(extendedOptions.middlewares);
+        }
+        if (extendedOptions.plugins) {
+            this.pluginManager = new _modules.PluginManager(this, extendedOptions.plugins);
+        }
+        if (extendedOptions.dataSources) {
+            this.dataSourceManager = new _modules.DataSourceManager(extendedOptions.dataSources, extendedOptions.dataSourceMergeStrategy);
+        }
+        // 从存储中恢复权限数据
+        this.restorePermissionData().catch((error)=>{
+            this.loggingManager.error('Failed to restore permission data:', error);
+        });
+        // 开发模式日志
+        if (this.options.devMode) {
+            this.loggingManager.debug('PermissionManager initialized', {
+                environment: this.environment,
+                isProduction: this.isProduction,
+                storageStrategy: this.options.storageStrategy
+            });
+        }
+    }
+    /**
+   * 从存储中恢复权限数据
+   */ async restorePermissionData() {
+        try {
+            if (this.options.storageStrategy === 'state') {
+                const data = await this.storageManager.restorePermissionData();
+                if (data) {
+                    // 解密数据（如果配置了加密）
+                    let permissionData;
+                    if (this.options.enableEncryption) {
+                        permissionData = await this.encryptionService.decryptPermissionData(data);
+                    } else {
+                        permissionData = data;
+                    }
+                    // 更新权限数据缓存
+                    this.updatePermissionDataCache(permissionData);
+                }
+            }
+        } catch (error) {
+            this.loggingManager.error('Failed to restore permission data:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'permission_restore',
+                operation: 'restorePermissionData'
+            });
+        }
+    }
+    /**
+   * 更新权限数据缓存（统一方法）
+   */ updatePermissionDataCache(permissionData) {
+        // 更新权限数据缓存
+        this.permissionDataCache.set('data', permissionData);
+        // 更新权限树缓存（如果启用）
+        if (this.options.enablePermissionTree && permissionData.permissionTree) {
+            this.permissionTreeCache.set('tree', permissionData.permissionTree);
+        }
+    }
+    /**
+   * 获取权限数据（从缓存）
+   */ getPermissionDataFromCache() {
+        return this.permissionDataCache.get('data');
+    }
+    /**
+   * 保存权限数据到存储
+   */ async savePermissionData(data) {
+        try {
+            // 加密数据（如果配置了加密）
+            let dataToSave = data;
+            if (this.options.enableEncryption) {
+                dataToSave = await this.encryptionService.encryptPermissionData(data);
+            }
+            if (this.options.storageStrategy === 'state') {
+                await this.storageManager.savePermissionData(dataToSave);
+            }
+        // 内存存储不需要保存，直接存储在内存中
+        } catch (error) {
+            this.loggingManager.error('Failed to save permission data:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'permission_save',
+                operation: 'savePermissionData'
+            });
+        }
+    }
+    /**
+   * 获取权限数据（从用户信息或 API）
+   * 注意：此方法当前未使用，保留用于将来扩展
+   */ // @ts-expect-error - 保留用于将来扩展
+    async _getPermissionData() {
+        // 如果配置了多数据源，使用数据源管理器
+        if (this.dataSourceManager) {
+            const permissionData = await this.dataSourceManager.fetchPermissionData();
+            if (permissionData) {
+                await this.savePermissionData(permissionData);
+                this.updatePermissionDataCache(permissionData);
+            }
+            return permissionData;
+        }
+        // 使用默认的数据管理器
+        const cachedData = this.getPermissionDataFromCache();
+        const permissionData = await this.permissionDataManager.getPermissionData(cachedData);
+        if (permissionData) {
+            await this.savePermissionData(permissionData);
+            this.updatePermissionDataCache(permissionData);
+        }
+        return permissionData;
+    }
+    // ========== 公共 API：权限检查 ==========
+    /**
+   * 检查用户是否拥有指定权限（同步模式）
+   * @param permission 权限标识（支持通配符和权限路径）
+   * @returns 是否拥有权限
+   */ hasPermission(permission) {
+        const startTime = Date.now();
+        const context = {
+            permission
+        };
+        try {
+            // 限流检查
+            if (this.rateLimiter && !this.rateLimiter.allow('permission_check')) {
+                const duration = Date.now() - startTime;
+                const result = {
+                    result: false,
+                    matchType: 'none',
+                    reason: 'rate_limited',
+                    duration
+                };
+                this.performanceMonitor.recordPerformance('hasPermission', duration, {
+                    permission,
+                    ...result
+                });
+                this.auditLogger?.log({
+                    operation: 'check',
+                    target: permission,
+                    result: 'denied',
+                    context: {
+                        reason: 'rate_limited'
+                    }
+                });
+                return false;
+            }
+            // 执行检查前中间件
+            if (this.middlewareManager) {
+                this.middlewareManager.executeBeforeCheck(permission, context).catch((error)=>{
+                    this.loggingManager.warn('Middleware beforeCheck error:', error);
+                });
+            }
+            // 执行插件检查前钩子
+            if (this.pluginManager) {
+                this.pluginManager.executeBeforePermissionCheck(permission, context).catch((error)=>{
+                    this.loggingManager.warn('Plugin beforePermissionCheck error:', error);
+                });
+            }
+            // 使用核心层检查权限
+            const result = this.permissionCore.hasPermission(permission);
+            const duration = Date.now() - startTime;
+            // 记录性能
+            this.performanceMonitor.recordPerformance('hasPermission', duration, {
+                permission,
+                result
+            });
+            // 执行检查后中间件
+            if (this.middlewareManager) {
+                const checkResult = {
+                    result,
+                    matchType: 'exact',
+                    duration
+                };
+                this.middlewareManager.executeAfterCheck(permission, checkResult, context).catch((error)=>{
+                    this.loggingManager.warn('Middleware afterCheck error:', error);
+                });
+            }
+            // 执行插件检查后钩子
+            if (this.pluginManager) {
+                const checkResult = {
+                    result,
+                    matchType: 'exact',
+                    duration
+                };
+                this.pluginManager.executeAfterPermissionCheck(permission, checkResult, context).catch((error)=>{
+                    this.loggingManager.warn('Plugin afterPermissionCheck error:', error);
+                });
+            }
+            // 记录审计日志
+            this.auditLogger?.log({
+                operation: 'check',
+                target: permission,
+                result: result ? 'success' : 'denied',
+                context: {}
+            });
+            // 触发事件
+            this.eventManager.emitEvent(_types.PermissionEventType.PERMISSION_CHECK, {
+                permission,
+                result,
+                duration
+            });
+            return result;
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            this.loggingManager.error('Error checking permission:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'permission_check',
+                permission
+            });
+            this.auditLogger?.log({
+                operation: 'check',
+                target: permission,
+                result: 'failure',
+                context: {
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            });
+            this.performanceMonitor.recordPerformance('hasPermission', duration, {
+                permission,
+                error: true
+            });
+            return false;
+        }
+    }
+    /**
+   * 检查用户是否拥有指定权限（异步模式，等待数据加载）
+   * @param permission 权限标识
+   * @returns Promise<是否拥有权限>
+   */ async hasPermissionAsync(permission) {
+        return this.permissionCore.hasPermissionAsync(permission);
+    }
+    /**
+   * 批量检查权限
+   * @param permissions 权限标识数组
+   * @returns 权限检查结果映射
+   */ hasPermissions(permissions) {
+        const startTime = Date.now();
+        const results = this.permissionCore.hasPermissions(permissions);
+        const duration = Date.now() - startTime;
+        this.performanceMonitor.recordPerformance('hasPermissions', duration, {
+            count: permissions.length
+        });
+        return results;
+    }
+    /**
+   * 检查用户是否拥有指定角色
+   * @param role 角色标识
+   * @returns 是否拥有角色
+   */ hasRole(role) {
+        const startTime = Date.now();
+        try {
+            const result = this.permissionCore.hasRole(role);
+            const duration = Date.now() - startTime;
+            this.performanceMonitor.recordPerformance('hasRole', duration, {
+                role
+            });
+            return result;
+        } catch (error) {
+            this.loggingManager.error('Error checking role:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'role_check',
+                role
+            });
+            return false;
+        }
+    }
+    /**
+   * 批量检查角色
+   * @param roles 角色标识数组
+   * @returns 角色检查结果映射
+   */ hasRoles(roles) {
+        const startTime = Date.now();
+        const results = this.permissionCore.hasRoles(roles);
+        const duration = Date.now() - startTime;
+        this.performanceMonitor.recordPerformance('hasRoles', duration, {
+            count: roles.length
+        });
+        return results;
+    }
+    // ========== 公共 API：权限数据获取 ==========
+    /**
+   * 获取所有权限
+   * @returns 权限标识数组
+   */ getPermissions() {
+        return this.permissionCore.getPermissions();
+    }
+    /**
+   * 获取所有角色
+   * @returns 角色标识数组
+   */ getRoles() {
+        return this.permissionCore.getRoles();
+    }
+    /**
+   * 获取权限树结构（如果支持）
+   * @returns 权限树结构
+   */ getPermissionTree() {
+        return this.permissionCore.getPermissionTree();
+    }
+    // ========== 公共 API：权限数据更新 ==========
+    /**
+   * 刷新权限数据
+   * @param force 是否强制刷新（忽略缓存）
+   * @returns 刷新后的权限数据
+   */ async refreshPermissions(force) {
+        const startTime = Date.now();
+        try {
+            const permissionData = await this.permissionCore.refreshPermissions(force);
+            // 触发事件
+            this.eventManager.emitEvent(_types.PermissionEventType.PERMISSIONS_REFRESHED, {
+                permissionData,
+                force
+            });
+            const duration = Date.now() - startTime;
+            this.performanceMonitor.recordPerformance('refreshPermissions', duration, {
+                force
+            });
+            this.loggingManager.info('Permissions refreshed', {
+                permissionCount: permissionData.permissions.length,
+                roleCount: permissionData.roles.length
+            });
+            return permissionData;
+        } catch (error) {
+            this.loggingManager.error('Failed to refresh permissions:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'permission_refresh',
+                operation: 'refreshPermissions'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 更新权限数据
+   * @param permissions 权限标识数组
+   * @param roles 角色标识数组
+   */ async updatePermissions(permissions, roles) {
+        const startTime = Date.now();
+        try {
+            // 执行更新前钩子
+            if (this.pluginManager) {
+                await this.pluginManager.executeBeforePermissionUpdate(permissions, roles);
+            }
+            const currentData = this.permissionCore.getPermissions();
+            const oldPermissions = currentData || [];
+            const oldRoles = this.permissionCore.getRoles() || [];
+            await this.permissionCore.updatePermissions(permissions, roles);
+            // 记录变更历史
+            if (this.changeHistory) {
+                const addedPermissions = permissions.filter((p)=>!oldPermissions.includes(p));
+                const removedPermissions = oldPermissions.filter((p)=>!permissions.includes(p));
+                addedPermissions.forEach((permission)=>{
+                    this.changeHistory.record({
+                        changeType: 'added',
+                        targetType: 'permission',
+                        target: permission,
+                        newValue: permissions,
+                        oldValue: oldPermissions
+                    });
+                });
+                removedPermissions.forEach((permission)=>{
+                    this.changeHistory.record({
+                        changeType: 'removed',
+                        targetType: 'permission',
+                        target: permission,
+                        newValue: permissions,
+                        oldValue: oldPermissions
+                    });
+                });
+                const addedRoles = roles.filter((r)=>!oldRoles.includes(r));
+                const removedRoles = oldRoles.filter((r)=>!roles.includes(r));
+                addedRoles.forEach((role)=>{
+                    this.changeHistory.record({
+                        changeType: 'added',
+                        targetType: 'role',
+                        target: role,
+                        newValue: roles,
+                        oldValue: oldRoles
+                    });
+                });
+                removedRoles.forEach((role)=>{
+                    this.changeHistory.record({
+                        changeType: 'removed',
+                        targetType: 'role',
+                        target: role,
+                        newValue: roles,
+                        oldValue: oldRoles
+                    });
+                });
+            }
+            // 触发权限状态变化事件
+            this.eventManager.emitEvent(_types.PermissionEventType.PERMISSION_STATE_CHANGED, {
+                permissions,
+                roles,
+                changeType: 'updated',
+                timestamp: Date.now()
+            });
+            // 触发更新事件
+            this.eventManager.emitEvent(_types.PermissionEventType.PERMISSIONS_UPDATED, {
+                permissions,
+                roles
+            });
+            // 执行更新后钩子
+            if (this.pluginManager) {
+                await this.pluginManager.executeAfterPermissionUpdate(permissions, roles);
+            }
+            const duration = Date.now() - startTime;
+            this.performanceMonitor.recordPerformance('updatePermissions', duration, {
+                permissionCount: permissions.length,
+                roleCount: roles.length
+            });
+            this.loggingManager.info('Permissions updated', {
+                permissionCount: permissions.length,
+                roleCount: roles.length
+            });
+        } catch (error) {
+            this.loggingManager.error('Failed to update permissions:', error);
+            this.monitoringManager.captureError(error, {
+                context: 'permission_update',
+                operation: 'updatePermissions'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 清除权限缓存
+   */ clearCache() {
+        this.permissionCore.clearCache();
+        // 触发事件
+        this.eventManager.emitEvent(_types.PermissionEventType.CACHE_CLEARED, {});
+        this.loggingManager.debug('Permission cache cleared');
+    }
+    // ========== 公共 API：事件订阅 ==========
+    /**
+   * 订阅事件
+   */ on(event, listener, options) {
+        return this.eventManager.on(event, listener, options);
+    }
+    /**
+   * 取消订阅
+   */ off(event, listener) {
+        this.eventManager.off(event, listener);
+    }
+    /**
+   * 一次性订阅
+   */ once(event, listener) {
+        return this.eventManager.once(event, listener);
+    }
+    // ========== 公共 API：高级功能 ==========
+    /**
+   * 健康检查
+   */ async healthCheck() {
+        const checks = {
+            storage: false,
+            eventBus: false,
+            permissionData: false
+        };
+        const details = {};
+        // 检查存储
+        try {
+            if (this.options.storageStrategy === 'state' && this.storageManager.getStateManager()) {
+                this.storageManager.getStateManager().get(this.storageKey);
+                checks.storage = true;
+            } else {
+                checks.storage = true; // 内存存储总是可用
+            }
+        } catch (error) {
+            details.storageError = error instanceof Error ? error.message : String(error);
+        }
+        // 检查事件总线
+        try {
+            const eventBus = this.eventManager.getEventBus();
+            if (eventBus) {
+                // 尝试触发一个测试事件
+                eventBus.emit('__health_check__', {});
+                checks.eventBus = true;
+            }
+        } catch (error) {
+            details.eventBusError = error instanceof Error ? error.message : String(error);
+        }
+        // 检查权限数据
+        const permissionData = this.getPermissionDataFromCache();
+        checks.permissionData = permissionData !== null;
+        if (!checks.permissionData) {
+            details.noPermissionData = true;
+        }
+        // 计算总体状态
+        const allHealthy = Object.values(checks).every((check)=>check === true);
+        const someHealthy = Object.values(checks).some((check)=>check === true);
+        let status;
+        if (allHealthy) {
+            status = 'healthy';
+        } else if (someHealthy) {
+            status = 'degraded';
+        } else {
+            status = 'unhealthy';
+        }
+        return {
+            status,
+            checks,
+            details: Object.keys(details).length > 0 ? details : undefined
+        };
+    }
+    /**
+   * 获取性能指标
+   */ getPerformanceMetrics() {
+        return this.performanceMonitor.getPerformanceMetrics();
+    }
+    /**
+   * 获取性能统计信息
+   */ getPerformanceStatistics(operation) {
+        return this.performanceMonitor.getStatistics(operation);
+    }
+    /**
+   * 清除性能指标
+   */ clearPerformanceMetrics() {
+        this.performanceMonitor.clearPerformanceMetrics();
+    }
+    /**
+   * 获取调试信息
+   */ getDebugInfo() {
+        const cacheStats = this.permissionCache.getStats();
+        const roleCacheStats = this.roleCache.getStats();
+        const performanceStats = this.getPerformanceStatistics();
+        const recentOperations = this.getPerformanceMetrics().slice(-10).map((m)=>({
+                operation: m.operation,
+                timestamp: m.timestamp,
+                duration: m.duration,
+                result: m.metadata?.result?.toString() || 'unknown'
+            }));
+        const permissions = this.permissionCore.getPermissions();
+        const roles = this.permissionCore.getRoles();
+        return {
+            instance: {
+                id: this.instanceId,
+                environment: this.environment,
+                isProduction: this.isProduction
+            },
+            config: {
+                storageStrategy: this.options.storageStrategy,
+                enableCache: this.options.enableCache,
+                enableEncryption: this.options.enableEncryption,
+                enablePermissionTree: this.options.enablePermissionTree,
+                enableWildcardMatch: this.options.enableWildcardMatch,
+                wildcardMatchMode: this.options.wildcardMatchMode
+            },
+            permissionData: {
+                loaded: permissions.length > 0 || roles.length > 0,
+                permissionCount: permissions.length,
+                roleCount: roles.length,
+                lastUpdated: undefined
+            },
+            cache: {
+                size: cacheStats.size + roleCacheStats.size,
+                hitRate: cacheStats.hitRate
+            },
+            performance: performanceStats,
+            recentOperations
+        };
+    }
+    /**
+   * 获取健康检查详细诊断信息
+   */ async getHealthCheckDiagnostics() {
+        const healthCheck = await this.healthCheck();
+        const cacheStats = this.permissionCache.getStats();
+        const roleCacheStats = this.roleCache.getStats();
+        const performanceStats = this.getPerformanceStatistics('hasPermission');
+        const hasPermissionStats = performanceStats.find((s)=>s.operation === 'hasPermission');
+        // 获取最近错误（从审计日志）
+        const recentErrors = [];
+        if (this.auditLogger) {
+            const errorLogs = this.auditLogger.getLogs({
+                result: 'failure',
+                limit: 5
+            });
+            recentErrors.push(...errorLogs.map((log)=>({
+                    code: 'AUDIT_ERROR',
+                    message: log.context?.error?.toString() || 'Unknown error',
+                    timestamp: log.timestamp
+                })));
+        }
+        const permissions = this.permissionCore.getPermissions();
+        const roles = this.permissionCore.getRoles();
+        return {
+            storage: {
+                available: healthCheck.checks.storage,
+                strategy: this.options.storageStrategy,
+                error: healthCheck.details?.storageError
+            },
+            cache: {
+                enabled: this.options.enableCache,
+                size: cacheStats.size + roleCacheStats.size,
+                hitRate: undefined
+            },
+            permissionData: {
+                loaded: healthCheck.checks.permissionData,
+                permissionCount: permissions.length,
+                roleCount: roles.length,
+                lastUpdated: undefined,
+                expiresAt: undefined
+            },
+            recentErrors,
+            performance: {
+                averageCheckDuration: hasPermissionStats?.averageDuration || 0,
+                totalChecks: hasPermissionStats?.count || 0,
+                errorRate: hasPermissionStats?.errorRate || 0
+            }
+        };
+    }
+    /**
+   * 获取审计日志
+   */ getAuditLogs(filter) {
+        if (!this.auditLogger) {
+            return [];
+        }
+        return this.auditLogger.getLogs(filter);
+    }
+    /**
+   * 导出审计日志
+   */ exportAuditLogs(format = 'json') {
+        if (!this.auditLogger) {
+            return '';
+        }
+        return this.auditLogger.export(format);
+    }
+    /**
+   * 获取变更历史
+   */ getChangeHistory(filter) {
+        if (!this.changeHistory) {
+            return [];
+        }
+        return this.changeHistory.getHistory(filter);
+    }
+    /**
+   * 获取环境信息
+   */ getEnvironment() {
+        return this.environment;
+    }
+    /**
+   * 销毁实例（清理资源）
+   */ destroy() {
+        // 清理所有事件监听器
+        this.eventManager.clearAllListeners();
+        // 销毁插件
+        if (this.pluginManager) {
+            this.pluginManager.destroy();
+        }
+        // 清理状态
+        this.permissionDataCache.clear();
+        this.permissionCache.clear();
+        this.roleCache.clear();
+        this.permissionTreeCache.clear();
+        // 清除性能指标
+        this.performanceMonitor.clearPerformanceMetrics();
+        // 重置限流器
+        if (this.rateLimiter) {
+            this.rateLimiter.reset();
+        }
+        // 清除并发控制队列
+        this.concurrencyController.clear();
+        this.loggingManager.debug('PermissionManager destroyed');
+    }
+    /**
+   * 构造函数
+   * @param options 配置选项
+   */ constructor(options){
+        _define_property(this, "authManager", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "environment", 'unknown');
+        _define_property(this, "isProduction", false);
+        _define_property(this, "instanceId", void 0);
+        _define_property(this, "storageKey", void 0);
+        // Core 层模块
+        _define_property(this, "permissionCore", void 0);
+        _define_property(this, "concurrencyController", void 0);
+        _define_property(this, "stateManager", void 0);
+        // Runtime 层模块
+        _define_property(this, "environmentAdapter", void 0);
+        // Observability 层模块（可选）
+        _define_property(this, "eventManager", void 0);
+        _define_property(this, "performanceMonitor", void 0);
+        _define_property(this, "loggingManager", void 0);
+        _define_property(this, "monitoringManager", void 0);
+        // 其他模块实例
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "encryptionService", void 0);
+        _define_property(this, "permissionChecker", void 0);
+        _define_property(this, "permissionDataManager", void 0);
+        _define_property(this, "permissionCache", void 0);
+        _define_property(this, "roleCache", void 0);
+        _define_property(this, "permissionDataCache", void 0);
+        _define_property(this, "permissionTreeCache", void 0);
+        // 可选模块实例
+        _define_property(this, "rateLimiter", void 0);
+        _define_property(this, "auditLogger", void 0);
+        _define_property(this, "changeHistory", void 0);
+        // strategyManager 将来会在权限检查中使用
+        // @ts-expect-error - 保留用于将来扩展
+        _define_property(this, "_strategyManager", void 0);
+        _define_property(this, "middlewareManager", void 0);
+        _define_property(this, "pluginManager", void 0);
+        _define_property(this, "dataSourceManager", void 0);
+        // 检测环境
+        this.environment = _modules.EnvironmentDetector.detectEnvironment();
+        this.isProduction = _modules.EnvironmentDetector.checkIsProduction();
+        // 验证必需配置
+        if (!options.authManager) {
+            throw new _types.PermissionError(_types.PermissionErrorCode.CONFIG_ERROR_001, 'authManager is required');
+        }
+        // 初始化 authManager
+        this.authManager = options.authManager;
+        // 合并配置
+        const extendedOptions = options;
+        this.options = {
+            ..._constants.DEFAULT_OPTIONS,
+            ...this.isProduction ? _constants.PRODUCTION_OVERRIDES : {},
+            ...(0, _configUtils.createConfig)(extendedOptions)
+        };
+        // 设置实例ID和存储键名
+        this.instanceId = this.options.instanceId || 'default';
+        const namespace = this.options.stateManager?.namespace || 'permission';
+        this.storageKey = `${namespace}:${this.instanceId}:permission_data`;
+        // 初始化模块
+        this.initializeModules();
+    }
+};
+
+//# sourceMappingURL=PermissionManager.js.map