@vlian/infrastructure 0.9.10

package/dist/cjs/managers/NotificationManager/NotificationManager.js

@@ -0,0 +1,607 @@
+/**
+ * NotificationManager - 通知管理器
+ * 
+ * 提供通知管理能力
+ * 完全泛型化，通知类型由用户定义
+ * 基于 @vlian/framework 的 Storage、StateManager 和 AppEventBus
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationManager", {
+    enumerable: true,
+    get: function() {
+        return NotificationManager;
+    }
+});
+const _types = require("./types");
+const _constants = require("./constants");
+const _core = require("./core");
+const _runtime = require("./runtime");
+const _observability = require("./observability");
+const _modules = require("./modules");
+const _utils = require("./utils");
+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 NotificationManager = class NotificationManager {
+    /**
+   * 初始化所有模块
+   */ initializeModules() {
+        // 初始化公共模块
+        if (this.options.storage || this.options.enablePersistentCache) {
+            this.storageManager = new _core.StorageManager({
+                storage: this.options.storage || {
+                    strategy: 'local'
+                },
+                environment: this.environment,
+                logger: this.options.logger
+            });
+        }
+        // ErrorHandler 暂时未使用，保留用于未来扩展
+        // 初始化 Observability 层
+        this.loggingManager = new _observability.LoggingManager({
+            logger: this.options.logger,
+            enableLogging: this.options.enableLogging,
+            context: {
+                instanceId: this.options.instanceId
+            }
+        });
+        this.monitoringManager = new _observability.MonitoringManager({
+            monitoring: this.options.monitoring,
+            enableMonitoring: this.options.enableMonitoring
+        });
+        this.performanceMonitor = new _observability.PerformanceMonitor({
+            monitoring: this.options.monitoring,
+            enableDetailedMetrics: this.options.enableDetailedMetrics
+        });
+        this.eventManager = new _observability.EventManager({
+            eventBus: this.options.eventBus,
+            eventNamespace: _utils.IsolationUtils.generateEventNamespace(this.options.eventNamespace, this.options.instanceId, this.options.isolationMode),
+            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 _core.StateManagerWrapper({
+            stateManager: this.options.stateManager,
+            logger: this.options.logger
+        }) : undefined;
+        this.cacheManager = new _core.CacheManager({
+            defaultTTL: this.options.cacheExpiry,
+            maxSize: this.options.maxCacheSize
+        });
+        this.concurrencyController = new _core.ConcurrencyController({
+            strategy: this.options.concurrencyStrategy,
+            maxQueueSize: this.options.maxQueueSize,
+            operationTimeout: this.options.operationTimeout
+        });
+        this.consistencyManager = new _core.ConsistencyManager({
+            enableVersionControl: this.options.enableVersionControl,
+            conflictStrategy: this.options.conflictStrategy,
+            conflictRetryCount: this.options.conflictRetryCount,
+            conflictRetryDelay: this.options.conflictRetryDelay,
+            enableOperationPriority: this.options.enableOperationPriority
+        });
+        if (this.options.enableTransaction) {
+            this.transactionManager = new _core.TransactionManager({
+                isolationLevel: this.options.transactionIsolationLevel,
+                defaultTimeout: this.options.transactionTimeout,
+                maxOperations: this.options.maxTransactionOperations,
+                autoCleanup: this.options.autoCleanupTransactions,
+                cleanupInterval: this.options.transactionCleanupInterval
+            });
+        }
+        // 获取用户ID
+        const userId = this.options.authManager.getUserId();
+        this.dataManager = new _core.NotificationDataManager({
+            cacheManager: this.cacheManager,
+            stateManager: this.stateManager,
+            storageManager: this.storageManager,
+            consistencyManager: this.consistencyManager,
+            concurrencyController: this.concurrencyController,
+            notificationFetcher: this.options.notificationFetcher,
+            notificationUpdater: this.options.notificationUpdater,
+            notificationBatchUpdater: this.options.notificationBatchUpdater,
+            notificationDeleter: this.options.notificationDeleter,
+            notificationBatchDeleter: this.options.notificationBatchDeleter,
+            notificationValidator: this.options.notificationValidator,
+            enableCache: this.options.enableCache,
+            enablePersistentCache: this.options.enablePersistentCache,
+            cacheExpiry: this.options.cacheExpiry,
+            notificationKeyPrefix: _utils.IsolationUtils.generateIsolatedKey(this.options.notificationKeyPrefix, this.options.instanceId, this.options.isolationMode),
+            userId
+        });
+        this.stateManagerCore = new _core.NotificationStateManager({
+            dataManager: this.dataManager,
+            consistencyManager: this.consistencyManager,
+            concurrencyController: this.concurrencyController
+        });
+        // 初始化实时推送管理器
+        if (this.options.pushStrategy !== 'disabled' && (this.options.websocket || this.options.polling)) {
+            this.pushManager = new _core.RealtimePushManager({
+                pushStrategy: this.options.pushStrategy,
+                websocket: this.options.websocket,
+                polling: this.options.polling,
+                onNotificationReceived: (notification)=>{
+                    // 处理新通知到达
+                    this.handleNotificationReceived(notification);
+                }
+            });
+        }
+    }
+    /**
+   * 处理新通知到达
+   */ async handleNotificationReceived(notification) {
+        // 更新本地缓存
+        const list = await this.dataManager.getNotifications();
+        list.items.unshift(notification);
+        list.total += 1;
+        // 更新缓存
+        const cacheKey = _utils.IsolationUtils.generateIsolatedKey(this.options.notificationKeyPrefix, this.options.instanceId, this.options.isolationMode) + 'list';
+        if (this.options.enableCache) {
+            this.cacheManager.set(cacheKey, list, this.options.cacheExpiry);
+        }
+        // 触发事件
+        this.eventManager.emit(_types.NotificationEventType.NOTIFICATION_RECEIVED, {
+            notification,
+            timestamp: Date.now()
+        });
+        // 更新未读数量（清除缓存以便重新计算）
+        this.stateManagerCore.clearUnreadCountCache();
+        const unreadCount = await this.stateManagerCore.getUnreadCount();
+        this.eventManager.emit(_types.NotificationEventType.UNREAD_COUNT_CHANGED, {
+            count: unreadCount,
+            previousCount: unreadCount - 1,
+            timestamp: Date.now()
+        });
+    }
+    /**
+   * 验证配置
+   */ validateConfig(options) {
+        const errors = [];
+        const warnings = [];
+        // 验证必需配置
+        if (!options.authManager) {
+            errors.push('authManager is required');
+        }
+        // 验证推送配置
+        if (options.pushStrategy === 'websocket' && !options.websocket) {
+            errors.push('websocket configuration is required when pushStrategy is "websocket"');
+        }
+        if (options.pushStrategy === 'polling' && !options.polling) {
+            errors.push('polling configuration is required when pushStrategy is "polling"');
+        }
+        // 验证缓存配置
+        if (options.enablePersistentCache && !options.storage) {
+            warnings.push('enablePersistentCache is true but storage is not provided');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    // ========== 公共 API ==========
+    /**
+   * 获取通知列表
+   */ async getNotifications(options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.dataManager.getNotifications(options);
+            this.performanceMonitor.recordMetric('getNotifications', Date.now() - startTime);
+            this.eventManager.emit(_types.NotificationEventType.NOTIFICATION_LOADED, {
+                notifications: result,
+                timestamp: Date.now()
+            });
+            return result;
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'getNotifications'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取通知列表（同步）
+   */ getNotificationsSync(options) {
+        return this.dataManager.getNotificationsSync(options);
+    }
+    /**
+   * 获取单个通知
+   */ async getNotification(id, options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.dataManager.getNotification(id, options);
+            this.performanceMonitor.recordMetric('getNotification', Date.now() - startTime);
+            return result;
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'getNotification',
+                id
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取单个通知（同步）
+   */ getNotificationSync(id, options) {
+        return this.dataManager.getNotificationSync(id, options);
+    }
+    /**
+   * 标记通知为已读
+   */ async markAsRead(id, options) {
+        const startTime = Date.now();
+        try {
+            await this.stateManagerCore.markAsRead(id, options);
+            this.performanceMonitor.recordMetric('markAsRead', Date.now() - startTime);
+            this.eventManager.emit(_types.NotificationEventType.NOTIFICATION_READ, {
+                id,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'markAsRead',
+                id
+            });
+            throw error;
+        }
+    }
+    /**
+   * 批量标记通知为已读
+   */ async batchMarkAsRead(ids, options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.stateManagerCore.batchMarkAsRead(ids, options);
+            this.performanceMonitor.recordMetric('batchMarkAsRead', Date.now() - startTime);
+            return result;
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'batchMarkAsRead',
+                ids
+            });
+            throw error;
+        }
+    }
+    /**
+   * 标记所有通知为已读
+   */ async markAllAsRead(options) {
+        const startTime = Date.now();
+        try {
+            await this.stateManagerCore.markAllAsRead(options);
+            this.performanceMonitor.recordMetric('markAllAsRead', Date.now() - startTime);
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'markAllAsRead'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 删除通知
+   */ async deleteNotification(id, _options) {
+        const startTime = Date.now();
+        try {
+            await this.dataManager.deleteNotification(id);
+            this.performanceMonitor.recordMetric('deleteNotification', Date.now() - startTime);
+            this.eventManager.emit(_types.NotificationEventType.NOTIFICATION_DELETED, {
+                id,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'deleteNotification',
+                id
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取未读通知数量
+   */ async getUnreadCount(options) {
+        const startTime = Date.now();
+        try {
+            const result = await this.stateManagerCore.getUnreadCount(options);
+            this.performanceMonitor.recordMetric('getUnreadCount', Date.now() - startTime);
+            return result;
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'getUnreadCount'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 获取未读通知数量（同步）
+   */ getUnreadCountSync(options) {
+        return this.stateManagerCore.getUnreadCountSync(options);
+    }
+    /**
+   * 按分类获取未读通知数量
+   */ async getUnreadCountByCategory(options) {
+        return this.stateManagerCore.getUnreadCountByCategory(options);
+    }
+    /**
+   * 按分类获取未读通知数量（同步）
+   */ getUnreadCountByCategorySync() {
+        return this.stateManagerCore.getUnreadCountByCategorySync();
+    }
+    /**
+   * 刷新通知列表
+   */ async refreshNotifications(force, _options) {
+        const startTime = Date.now();
+        try {
+            await this.dataManager.getNotifications({
+                force: force ?? true
+            });
+            this.performanceMonitor.recordMetric('refreshNotifications', Date.now() - startTime);
+            this.eventManager.emit(_types.NotificationEventType.NOTIFICATIONS_REFRESHED, {
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.monitoringManager.captureError(error, {
+                operation: 'refreshNotifications'
+            });
+            throw error;
+        }
+    }
+    /**
+   * 清除通知缓存
+   */ async clearCache(options) {
+        this.dataManager.clearCache(options?.clearPersistentCache);
+        // 清除未读数量缓存
+        this.stateManagerCore.clearUnreadCountCache();
+        this.eventManager.emit(_types.NotificationEventType.NOTIFICATIONS_REFRESHED, {
+            timestamp: Date.now()
+        });
+    }
+    /**
+   * 启动实时推送
+   */ async startRealtimePush(options) {
+        if (!this.pushManager) {
+            throw new _types.NotificationError('Realtime push is not configured', _types.NotificationErrorCode.PUSH_ERROR);
+        }
+        await this.pushManager.startRealtimePush(options);
+    }
+    /**
+   * 停止实时推送
+   */ stopRealtimePush() {
+        this.pushManager?.stopRealtimePush();
+    }
+    /**
+   * 获取推送连接状态
+   */ getPushConnectionStatus() {
+        return this.pushManager?.getPushConnectionStatus() || {
+            status: 'disconnected',
+            strategy: 'disabled'
+        };
+    }
+    /**
+   * 手动触发轮询
+   */ async triggerPolling() {
+        if (!this.pushManager) {
+            throw new _types.NotificationError('Realtime push is not configured', _types.NotificationErrorCode.PUSH_ERROR);
+        }
+        await this.pushManager.triggerPolling();
+    }
+    /**
+   * 过滤通知列表
+   */ filterNotifications(notifications, filter) {
+        return _runtime.NotificationFilter.filter(notifications, filter);
+    }
+    /**
+   * 搜索通知列表
+   */ searchNotifications(notifications, keyword, options) {
+        return _runtime.NotificationSearcher.search(notifications, keyword, options);
+    }
+    /**
+   * 订阅事件
+   */ 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);
+    }
+    /**
+   * 健康检查
+   */ async healthCheck() {
+        const checks = {};
+        // 检查存储
+        if (this.storageManager) {
+            try {
+                await this.storageManager.get('__health_check__');
+                checks.storage = {
+                    healthy: true
+                };
+            } catch (error) {
+                checks.storage = {
+                    healthy: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+        // 检查状态管理
+        if (this.stateManager) {
+            try {
+                this.stateManager.get('health_check');
+                checks.stateManager = {
+                    healthy: true
+                };
+            } catch (error) {
+                checks.stateManager = {
+                    healthy: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+        // 检查事件总线
+        if (this.options.enableEvents) {
+            checks.eventBus = {
+                healthy: true
+            };
+        }
+        // 检查推送连接
+        if (this.pushManager) {
+            const status = this.pushManager.getPushConnectionStatus();
+            checks.pushConnection = {
+                healthy: status.status === 'connected',
+                error: status.error
+            };
+        }
+        const healthy = Object.values(checks).every((check)=>check?.healthy !== false);
+        return {
+            healthy,
+            checks,
+            timestamp: Date.now()
+        };
+    }
+    /**
+   * 获取性能指标
+   */ 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() {
+        this.pushManager?.destroy();
+        this.transactionManager?.destroy();
+        this.eventManager.cleanup();
+        this.cacheManager.clear();
+        this.concurrencyController.clear();
+        this.consistencyManager.clear();
+    }
+    /**
+   * 构造函数
+   */ constructor(options){
+        _define_property(this, "options", void 0);
+        _define_property(this, "environment", void 0);
+        _define_property(this, "isProduction", void 0);
+        // 模块实例（在 initializeModules() 中初始化）
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "stateManager", void 0);
+        // Core 层
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "concurrencyController", void 0);
+        _define_property(this, "consistencyManager", void 0);
+        _define_property(this, "transactionManager", void 0);
+        _define_property(this, "dataManager", void 0);
+        _define_property(this, "stateManagerCore", void 0);
+        _define_property(this, "pushManager", void 0);
+        // Runtime 层
+        // (纯工具函数，无需实例)
+        // 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 = _modules.EnvironmentDetector.detect();
+        this.isProduction = _modules.EnvironmentDetector.checkIsProduction?.() ?? false;
+        // 验证必需配置
+        if (!options.authManager) {
+            throw new _types.NotificationError('authManager is required', _types.NotificationErrorCode.INVALID_CONFIG);
+        }
+        // 合并默认配置
+        this.options = {
+            ..._constants.DEFAULT_OPTIONS,
+            ...options,
+            authManager: options.authManager,
+            userManager: options.userManager,
+            storage: options.storage,
+            stateManager: options.stateManager,
+            eventBus: options.eventBus,
+            logger: options.logger,
+            monitoring: options.monitoring,
+            notificationFetcher: options.notificationFetcher,
+            notificationUpdater: options.notificationUpdater,
+            notificationBatchUpdater: options.notificationBatchUpdater,
+            notificationDeleter: options.notificationDeleter,
+            notificationBatchDeleter: options.notificationBatchDeleter,
+            notificationValidator: options.notificationValidator,
+            websocket: options.websocket,
+            polling: options.polling,
+            categories: options.categories,
+            instanceId: options.instanceId
+        };
+        // 应用生产环境覆盖
+        if (this.isProduction) {
+            this.options = {
+                ...this.options,
+                ..._constants.PRODUCTION_OVERRIDES
+            };
+        }
+        // 配置验证
+        if (this.options.validateConfig !== false) {
+            const validation = this.validateConfig(this.options);
+            if (!validation.valid) {
+                const errorMsg = `Configuration validation failed: ${validation.errors.join(', ')}`;
+                if (this.options.devMode) {
+                    throw new _types.NotificationError(`${errorMsg}\nWarnings: ${validation.warnings.join(', ')}`, _types.NotificationErrorCode.INVALID_CONFIG);
+                } else {
+                    throw new _types.NotificationError(errorMsg, _types.NotificationErrorCode.INVALID_CONFIG);
+                }
+            }
+            if (validation.warnings.length > 0 && this.options.devMode) {
+                validation.warnings.forEach((warning)=>{
+                    this.options.logger?.warn(`Config warning: ${warning}`);
+                });
+            }
+        }
+        // 初始化模块
+        this.initializeModules();
+        // 开发模式日志
+        if (this.options.devMode && this.options.enableLogging) {
+            this.loggingManager?.debug('NotificationManager initialized', {
+                environment: this.environment,
+                isProduction: this.isProduction,
+                instanceId: this.options.instanceId
+            });
+        }
+    }
+};
+
+//# sourceMappingURL=NotificationManager.js.map