@vlian/infrastructure 0.9.10

package/dist/esm/managers/SystemConfigManager/SystemConfigManager.js

@@ -0,0 +1,685 @@
+/**
+ * SystemConfigManager - 系统配置管理器
+ * 
+ * 提供系统配置管理能力
+ * 完全泛型化，配置类型由用户定义
+ * 基于 @vlian/framework 的 Storage、StateManager 和 AppEventBus
+ */ 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;
+}
+import { SystemConfigEventType } from "./types";
+import { DEFAULT_OPTIONS, PRODUCTION_OVERRIDES } from "./constants";
+// 导入 Core 层
+import { CacheManager, ConcurrencyController, ConfigDataManager, ConfigValidator, ConsistencyManager, StateManagerWrapper, SyncManager } from "./core";
+// 导入 Runtime 层
+import { DiffCalculator } from "./runtime";
+// 导入 Observability 层
+import { EventManager, PerformanceMonitor, LoggingManager, MonitoringManager } from "./observability";
+// 导入公共模块
+import { StorageManager, EnvironmentDetector, ErrorHandler } from "./modules";
+/**
+ * SystemConfigManager 类
+ */ export class SystemConfigManager {
+    /**
+   * 初始化所有模块
+   */ initializeModules() {
+        // 初始化公共模块
+        if (this.options.storage || this.options.enablePersistentCache) {
+            this.storageManager = new StorageManager({
+                storage: this.options.storage || {
+                    strategy: 'local'
+                },
+                environment: this.environment,
+                logger: this.options.logger
+            });
+        }
+        this.errorHandler = new ErrorHandler({
+            logger: this.options.logger,
+            monitoring: this.options.monitoring,
+            sanitizeErrors: this.isProduction
+        });
+        // 初始化 Observability 层
+        this.loggingManager = new LoggingManager({
+            logger: this.options.logger,
+            enableLogging: this.options.enableLogging,
+            context: {
+                instanceId: this.instanceId
+            }
+        });
+        this.monitoringManager = new MonitoringManager({
+            monitoring: this.options.monitoring,
+            enableMonitoring: this.options.enableMonitoring
+        });
+        this.performanceMonitor = new PerformanceMonitor({
+            monitoring: this.options.monitoring,
+            enableDetailedMetrics: this.options.enableDetailedMetrics
+        });
+        this.eventManager = new EventManager({
+            eventBus: this.options.eventBus,
+            eventNamespace: this.options.eventNamespace,
+            enableEvents: this.options.enableEvents,
+            logger: this.options.enableLogging ? {
+                debug: (...args)=>this.loggingManager.debug(...args),
+                error: (...args)=>this.loggingManager.error(...args)
+            } : undefined,
+            monitoring: this.options.enableMonitoring ? {
+                trackEvent: (name, props)=>this.monitoringManager.trackEvent(name, props),
+                captureError: (error, ctx)=>this.monitoringManager.captureError(error, ctx)
+            } : undefined
+        });
+        // 初始化 Core 层
+        this.stateManager = this.options.stateManager ? new StateManagerWrapper({
+            stateManager: this.options.stateManager,
+            logger: this.options.logger
+        }) : undefined;
+        this.cacheManager = new CacheManager({
+            defaultTTL: this.options.cacheExpiry
+        });
+        this.consistencyCacheManager = new CacheManager({
+            defaultTTL: undefined
+        });
+        this.concurrencyController = new ConcurrencyController({
+            strategy: this.options.concurrencyStrategy,
+            maxQueueSize: this.options.maxQueueSize,
+            operationTimeout: this.options.operationTimeout
+        });
+        this.validator = new ConfigValidator({
+            configValidator: this.options.configValidator,
+            configTypes: this.options.configTypes,
+            validateConfig: this.options.validateConfig ?? true
+        });
+        this.consistencyManager = new ConsistencyManager({
+            cacheManager: this.consistencyCacheManager,
+            enableConsistencyLevel: this.options.enableConsistencyLevel ?? true
+        });
+        this.dataManager = new ConfigDataManager({
+            cacheManager: this.cacheManager,
+            stateManager: this.stateManager,
+            storageManager: this.storageManager,
+            validator: this.validator,
+            consistencyManager: this.consistencyManager,
+            configFetcher: this.options.configFetcher,
+            configData: this.options.configData,
+            defaultConfig: this.options.defaultConfig,
+            enableCache: this.options.enableCache ?? true,
+            enablePersistentCache: this.options.enablePersistentCache ?? false,
+            cacheExpiry: this.options.cacheExpiry,
+            configKeyPrefix: this.options.configKeyPrefix
+        });
+        // 初始化同步管理器（如果有配置更新函数）
+        if (this.options.configUpdater || this.options.configBatchUpdater) {
+            this.syncManager = new SyncManager({
+                consistencyManager: this.consistencyManager,
+                storageManager: this.storageManager,
+                configUpdater: this.options.configUpdater,
+                configBatchUpdater: this.options.configBatchUpdater,
+                syncStrategy: this.options.syncStrategy ?? 'queue',
+                batchSyncDelay: this.options.batchSyncDelay ?? 1000,
+                syncRetryConfig: {
+                    maxRetries: this.options.syncRetryConfig?.maxRetries ?? 3,
+                    retryDelay: this.options.syncRetryConfig?.retryDelay ?? 1000,
+                    backoffMultiplier: this.options.syncRetryConfig?.backoffMultiplier ?? 2
+                },
+                enableOfflineQueue: this.options.enableOfflineQueue ?? true,
+                offlineQueueKey: `${this.options.configKeyPrefix}offline_queue`
+            });
+        }
+    // 初始化 Runtime 层
+    // diffCalculator 在需要时动态创建，以支持不同的泛型类型
+    // this.diffCalculator = new DiffCalculator<TConfig>({
+    //   configChangeDetector: this.options.configChangeDetector,
+    // });
+    // 保留用于未来配置合并和格式化功能
+    // this.configMerger = new ConfigMerger();
+    // this.configFormatter = new ConfigFormatter();
+    }
+    /**
+   * 获取配置值（异步）
+   */ async getConfig(key, defaultValue, options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.concurrencyController.execute(()=>this.dataManager.getConfig(key, {
+                    force: options?.force,
+                    usePersistentCache: options?.usePersistentCache
+                }), 'getConfig');
+            const value = result ?? defaultValue ?? null;
+            // 记录性能指标
+            this.performanceMonitor.recordMetric('getConfig', Date.now() - startTime, {
+                key
+            });
+            // 触发事件
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_LOADED, {
+                key,
+                value
+            });
+            return value;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'getConfig',
+                key
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取配置值（同步，仅读取缓存）
+   */ getConfigSync(key, defaultValue, options) {
+        try {
+            const result = this.dataManager.getConfigSync(key, options);
+            return result ?? defaultValue ?? null;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'getConfigSync',
+                key
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取所有配置（异步）
+   */ async getAllConfig(options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.concurrencyController.execute(()=>this.dataManager.getAllConfig({
+                    force: options?.force,
+                    usePersistentCache: options?.usePersistentCache
+                }), 'getAllConfig');
+            // 记录性能指标
+            this.performanceMonitor.recordMetric('getAllConfig', Date.now() - startTime);
+            // 触发事件
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_LOADED, {
+                configs: result
+            });
+            return result;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'getAllConfig'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取所有配置（同步，仅读取缓存）
+   */ getAllConfigSync(options) {
+        try {
+            return this.dataManager.getAllConfigSync(options);
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'getAllConfigSync'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 批量获取配置值（异步）
+   */ async getConfigs(keys, options) {
+        const startTime = Date.now();
+        try {
+            // 将整个批量操作作为一个整体进行并发控制
+            const result = await this.concurrencyController.execute(async ()=>{
+                const configs = {};
+                // 内部直接调用数据管理器，避免再次经过并发控制
+                await Promise.all(keys.map(async (key)=>{
+                    try {
+                        const value = await this.dataManager.getConfig(key, {
+                            force: options?.force,
+                            usePersistentCache: options?.usePersistentCache
+                        });
+                        configs[key] = value ?? null;
+                    } catch (error) {
+                        // 单个配置获取失败时，设置为 null，不中断整个批量操作
+                        configs[key] = null;
+                    }
+                }));
+                return configs;
+            }, 'getConfigs');
+            // 记录性能指标
+            this.performanceMonitor.recordMetric('getConfigs', Date.now() - startTime, {
+                count: keys.length
+            });
+            // 触发事件
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_LOADED, {
+                configs: result
+            });
+            return result;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'getConfigs',
+                keys
+            });
+            throw error;
+        }
+    }
+    /**
+   * 批量获取配置值（同步，仅读取缓存）
+   */ getConfigsSync(keys, options) {
+        const result = {};
+        for (const key of keys){
+            try {
+                const value = this.getConfigSync(key, undefined, options);
+                result[key] = value;
+            } catch (error) {
+                result[key] = null;
+            }
+        }
+        return result;
+    }
+    /**
+   * 更新配置值
+   */ async updateConfig(key, value, options) {
+        const startTime = Date.now();
+        try {
+            const previousValue = this.dataManager.getConfigSync(key);
+            await this.concurrencyController.execute(async ()=>{
+                await this.dataManager.setConfig(key, value, this.options.enablePersistentCache);
+                // 如果启用同步，使用同步管理器
+                if (this.syncManager) {
+                    await this.syncManager.syncConfig(key, value, options?.immediateSync);
+                } else {
+                    // 没有同步管理器，直接标记为 local
+                    this.consistencyManager.setConsistency(key, 'local');
+                }
+            }, 'updateConfig');
+            // 记录性能指标
+            this.performanceMonitor.recordMetric('updateConfig', Date.now() - startTime, {
+                key
+            });
+            // 触发事件
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_UPDATED, {
+                key,
+                value,
+                previousValue,
+                consistencyLevel: this.consistencyManager.getConsistency(key) || 'local',
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'updateConfig',
+                key
+            });
+            throw error;
+        }
+    }
+    /**
+   * 批量更新配置值
+   */ async batchUpdateConfig(configs, options) {
+        const startTime = Date.now();
+        try {
+            const previousConfigs = this.dataManager.getAllConfigSync();
+            const updated = [];
+            const failed = {};
+            await this.concurrencyController.execute(async ()=>{
+                await this.dataManager.setAllConfig(configs, this.options.enablePersistentCache);
+                // 如果启用同步，使用同步管理器
+                if (this.syncManager) {
+                    try {
+                        await this.syncManager.syncBatchConfigs(configs, options?.immediateSync);
+                        for (const key of Object.keys(configs)){
+                            updated.push(key);
+                        }
+                    } catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        for (const key of Object.keys(configs)){
+                            failed[key] = errorMessage;
+                        }
+                    }
+                } else {
+                    // 没有同步管理器，直接标记为 local
+                    for (const key of Object.keys(configs)){
+                        this.consistencyManager.setConsistency(key, 'local');
+                        updated.push(key);
+                    }
+                }
+            }, 'batchUpdateConfig');
+            // 计算差异
+            let diff;
+            if (this.options.enableDiff) {
+                const diffCalc = new DiffCalculator({
+                    configChangeDetector: this.options.configChangeDetector
+                });
+                diff = diffCalc.calculateDiff(configs, previousConfigs);
+            }
+            // 记录性能指标
+            this.performanceMonitor.recordMetric('batchUpdateConfig', Date.now() - startTime, {
+                count: Object.keys(configs).length
+            });
+            // 触发事件
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_UPDATED, {
+                configs: configs,
+                previousConfigs: previousConfigs,
+                diff,
+                timestamp: Date.now()
+            });
+            return {
+                success: Object.keys(failed).length === 0,
+                updated,
+                failed
+            };
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'batchUpdateConfig'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 刷新配置（从服务器获取最新数据）
+   */ async refreshConfig(key, force) {
+        try {
+            if (key) {
+                await this.getConfig(key, undefined, {
+                    force: force ?? true
+                });
+            } else {
+                await this.getAllConfig({
+                    force: force ?? true
+                });
+            }
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_REFRESHED, {
+                key,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'refreshConfig',
+                key
+            });
+            throw error;
+        }
+    }
+    /**
+   * 清除配置缓存
+   */ async clearCache(key) {
+        try {
+            await this.dataManager.clearCache(key);
+            this.eventManager.emitEvent(SystemConfigEventType.CONFIG_CACHE_CLEARED, {
+                key,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'clearCache',
+                key
+            });
+            throw error;
+        }
+    }
+    /**
+   * 验证配置值
+   */ validateConfig(key, value) {
+        return this.validator.validate(key, value);
+    }
+    /**
+   * 验证所有配置
+   */ validateAllConfig(configs) {
+        return this.validator.validateAll(configs);
+    }
+    /**
+   * 获取配置的一致性级别
+   */ async getConfigConsistency(key) {
+        if (key) {
+            return this.consistencyManager.getConsistency(key) || 'local';
+        }
+        return this.consistencyManager.getAllConsistency();
+    }
+    /**
+   * 获取配置的一致性级别（同步，仅读取缓存）
+   */ getConfigConsistencySync(key) {
+        if (key) {
+            return this.consistencyManager.getConsistency(key) || 'local';
+        }
+        return this.consistencyManager.getAllConsistency();
+    }
+    /**
+   * 按一致性级别过滤配置键名
+   */ async getConfigsByConsistency(level) {
+        return this.consistencyManager.getConfigsByConsistency(level);
+    }
+    /**
+   * 按一致性级别过滤配置键名（同步，仅读取缓存）
+   */ getConfigsByConsistencySync(level) {
+        return this.consistencyManager.getConfigsByConsistency(level);
+    }
+    /**
+   * 计算配置差异
+   */ async calculateConfigDiff(newConfig, oldConfig) {
+        if (!oldConfig) {
+            oldConfig = this.dataManager.getAllConfigSync();
+        }
+        const diffCalc = new DiffCalculator({
+            configChangeDetector: this.options.configChangeDetector
+        });
+        return diffCalc.calculateDiff(newConfig, oldConfig);
+    }
+    /**
+   * 计算配置差异（同步，仅读取缓存）
+   */ calculateConfigDiffSync(newConfig, oldConfig) {
+        if (!oldConfig) {
+            oldConfig = this.dataManager.getAllConfigSync();
+        }
+        const diffCalc = new DiffCalculator({
+            configChangeDetector: this.options.configChangeDetector
+        });
+        return diffCalc.calculateDiff(newConfig, oldConfig);
+    }
+    /**
+   * 应用配置差异（Patch）
+   */ async applyConfigPatch(diff) {
+        try {
+            // 应用新增项
+            if (Object.keys(diff.added).length > 0) {
+                await this.batchUpdateConfig(diff.added);
+            }
+            // 应用变更项
+            if (Object.keys(diff.changed).length > 0) {
+                const changedConfigs = {};
+                for (const [key, { after }] of Object.entries(diff.changed)){
+                    changedConfigs[key] = after;
+                }
+                await this.batchUpdateConfig(changedConfigs);
+            }
+            // 应用删除项
+            if (Object.keys(diff.removed).length > 0) {
+                for (const key of Object.keys(diff.removed)){
+                    await this.dataManager.deleteConfig(key);
+                }
+            }
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                operation: 'applyConfigPatch'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 订阅事件
+   */ on(event, listener, options) {
+        return this.eventManager.on(event, listener, options);
+    }
+    /**
+   * 取消订阅
+   */ off(event, listener) {
+        this.eventManager.off(event, listener);
+    }
+    /**
+   * 一次性订阅
+   */ once(event, listener, _options) {
+        return this.eventManager.once(event, listener);
+    }
+    /**
+   * 健康检查
+   */ async healthCheck() {
+        const checks = {};
+        // 检查存储
+        if (this.storageManager) {
+            try {
+                await this.storageManager.get('__health_check__');
+                checks.storage = {
+                    available: true
+                };
+            } catch (error) {
+                checks.storage = {
+                    available: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+        // 检查状态管理
+        if (this.stateManager) {
+            checks.stateManager = {
+                available: true
+            };
+        }
+        // 检查事件总线
+        if (this.options.eventBus) {
+            checks.eventBus = {
+                available: true
+            };
+        }
+        // 检查日志
+        if (this.options.logger) {
+            checks.logger = {
+                available: true
+            };
+        }
+        // 检查监控
+        if (this.options.monitoring) {
+            checks.monitoring = {
+                available: true
+            };
+        }
+        const healthy = Object.values(checks).every((check)=>check?.available !== false);
+        return {
+            healthy,
+            checks
+        };
+    }
+    /**
+   * 获取性能指标
+   */ getPerformanceMetrics() {
+        return this.performanceMonitor.getMetrics();
+    }
+    /**
+   * 清除性能指标
+   */ clearPerformanceMetrics() {
+        this.performanceMonitor.clearMetrics();
+    }
+    /**
+   * 获取缓存统计信息
+   */ getCacheStatistics() {
+        const stats = this.cacheManager.getStatistics();
+        return {
+            hits: stats.hits,
+            misses: stats.misses,
+            size: stats.size,
+            hitRate: stats.hitRate
+        };
+    }
+    /**
+   * 重置缓存统计信息
+   */ resetCacheStatistics() {
+        this.cacheManager.resetStatistics();
+    }
+    /**
+   * 销毁实例（清理资源）
+   */ destroy() {
+        // 强制处理所有待同步任务
+        if (this.syncManager) {
+            this.syncManager.flush().catch(()=>{
+            // 静默失败
+            });
+        }
+        this.eventManager.destroy();
+        this.cacheManager.clear();
+        this.consistencyCacheManager.clear();
+        this.concurrencyController.clear();
+        // 清除同步管理器
+        if (this.syncManager) {
+            this.syncManager.clear().catch(()=>{
+            // 静默失败
+            });
+        }
+    }
+    /**
+   * 构造函数
+   */ constructor(options){
+        _define_property(this, "options", void 0);
+        _define_property(this, "environment", void 0);
+        _define_property(this, "isProduction", void 0);
+        _define_property(this, "instanceId", void 0);
+        // 模块实例
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "stateManager", void 0);
+        _define_property(this, "errorHandler", void 0);
+        // Core 层
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "consistencyCacheManager", void 0);
+        _define_property(this, "concurrencyController", void 0);
+        _define_property(this, "validator", void 0);
+        _define_property(this, "consistencyManager", void 0);
+        _define_property(this, "dataManager", void 0);
+        _define_property(this, "syncManager", void 0);
+        // Runtime 层
+        // diffCalculator 在需要时动态创建，以支持不同的泛型类型
+        // private diffCalculator!: DiffCalculator<TConfig>;
+        // private configMerger!: ConfigMerger; // 保留用于未来配置合并功能
+        // private configFormatter!: ConfigFormatter; // 保留用于未来配置格式化功能
+        // Observability 层
+        _define_property(this, "loggingManager", void 0);
+        _define_property(this, "monitoringManager", void 0);
+        _define_property(this, "performanceMonitor", void 0);
+        _define_property(this, "eventManager", void 0);
+        // 检测环境
+        this.environment = EnvironmentDetector.detectEnvironment();
+        this.isProduction = EnvironmentDetector.checkIsProduction();
+        this.instanceId = options.instanceId || `system_config_${Date.now()}`;
+        // 合并默认配置
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+            storage: options.storage,
+            stateManager: options.stateManager,
+            eventBus: options.eventBus,
+            logger: options.logger,
+            monitoring: options.monitoring,
+            configFetcher: options.configFetcher,
+            configUpdater: options.configUpdater,
+            configBatchUpdater: options.configBatchUpdater,
+            configData: options.configData,
+            defaultConfig: options.defaultConfig,
+            configValidator: options.configValidator,
+            configTypes: options.configTypes,
+            configChangeDetector: options.configChangeDetector,
+            instanceId: this.instanceId
+        };
+        // 应用生产环境覆盖
+        if (this.isProduction) {
+            this.options = {
+                ...this.options,
+                ...PRODUCTION_OVERRIDES
+            };
+        }
+        // 初始化模块
+        this.initializeModules();
+        // 开发模式日志
+        if (this.options.devMode && this.options.enableLogging) {
+            this.loggingManager?.debug('SystemConfigManager initialized', {
+                environment: this.environment,
+                isProduction: this.isProduction,
+                instanceId: this.instanceId
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=SystemConfigManager.js.map