monsqlize 1.3.0 → 2.0.0

package/lib/saga/SagaExecutor.js

@@ -1,201 +0,0 @@
-/**
- * Saga 执行器
- * 负责步骤执行和补偿
- */
-const SagaContext = require('./SagaContext');
-
-class SagaExecutor {
-    /**
-     * 构造函数
-     * @param {Object} definition - Saga 定义
-     * @param {Object} data - 执行数据
-     * @param {Object} orchestrator - Saga 协调器
-     */
-    constructor(definition, data, orchestrator) {
-        this.definition = definition;
-        this.orchestrator = orchestrator;
-        this.context = new SagaContext(this._generateSagaId(), data);
-        this.completedSteps = [];
-    }
-
-    /**
-     * 执行 Saga
-     * @returns {Promise<Object>} 执行结果
-     */
-    async execute() {
-        const startTime = Date.now();
-
-        this.orchestrator.logger?.info(
-            `[Saga] 开始执行: ${this.definition.name} (${this.context.sagaId})`
-        );
-
-        try {
-            // 顺序执行步骤
-            for (let i = 0; i < this.definition.steps.length; i++) {
-                const step = this.definition.steps[i];
-
-                this.orchestrator.logger?.info(
-                    `[Saga] 执行步骤 ${i + 1}/${this.definition.steps.length}: ${step.name}`
-                );
-
-                const stepStartTime = Date.now();
-
-                // 执行步骤
-                const result = await step.execute(this.context);
-
-                const stepDuration = Date.now() - stepStartTime;
-
-                // 记录成功的步骤
-                this.completedSteps.push({
-                    step,
-                    index: i,
-                    result,
-                    duration: stepDuration,
-                    timestamp: Date.now()
-                });
-
-                // 标记步骤完成
-                this.context.markStepCompleted(step.name, result);
-
-                this.orchestrator.logger?.info(
-                    `[Saga] 步骤完成: ${step.name} (耗时 ${stepDuration}ms)`
-                );
-            }
-
-            const totalDuration = Date.now() - startTime;
-
-            this.orchestrator.logger?.info(
-                `[Saga] 执行成功: ${this.definition.name} (总耗时 ${totalDuration}ms)`
-            );
-
-            return {
-                success: true,
-                sagaId: this.context.sagaId,
-                sagaName: this.definition.name,
-                completedSteps: this.completedSteps.length,
-                duration: totalDuration
-            };
-
-        } catch (error) {
-            const totalDuration = Date.now() - startTime;
-
-            this.orchestrator.logger?.error(
-                `[Saga] 执行失败: ${this.definition.name}, 错误: ${error.message}`
-            );
-
-            // 自动补偿
-            const compensationResult = await this._compensate(error);
-
-            return {
-                success: false,
-                sagaId: this.context.sagaId,
-                sagaName: this.definition.name,
-                completedSteps: this.completedSteps.length,
-                failedStep: this.completedSteps.length,
-                error: error.message,
-                duration: totalDuration,
-                compensation: compensationResult
-            };
-        }
-    }
-
-    /**
-     * 补偿已完成的步骤
-     * @private
-     * @param {Error} originalError - 原始错误
-     * @returns {Promise<Object>} 补偿结果
-     */
-    async _compensate(originalError) {
-        this.orchestrator.logger?.warn(
-            `[Saga] 开始补偿: ${this.completedSteps.length} 个已完成步骤`
-        );
-
-        const compensationResults = [];
-
-        // 逆序补偿
-        for (let i = this.completedSteps.length - 1; i >= 0; i--) {
-            const completed = this.completedSteps[i];
-            const step = completed.step;
-
-            if (!step.compensate) {
-                this.orchestrator.logger?.warn(
-                    `[Saga] 步骤 ${step.name} 没有定义补偿操作，跳过`
-                );
-
-                compensationResults.push({
-                    stepName: step.name,
-                    success: false,
-                    reason: 'no-compensate-defined'
-                });
-
-                continue;
-            }
-
-            try {
-                this.orchestrator.logger?.info(
-                    `[Saga] 补偿步骤: ${step.name}`
-                );
-
-                const startTime = Date.now();
-
-                await step.compensate(this.context, completed.result);
-
-                const duration = Date.now() - startTime;
-
-                this.orchestrator.logger?.info(
-                    `[Saga] 补偿成功: ${step.name} (耗时 ${duration}ms)`
-                );
-
-                compensationResults.push({
-                    stepName: step.name,
-                    success: true,
-                    duration
-                });
-
-            } catch (compensateError) {
-                this.orchestrator.logger?.error(
-                    `[Saga] 补偿失败: ${step.name}, 错误: ${compensateError.message}`
-                );
-
-                compensationResults.push({
-                    stepName: step.name,
-                    success: false,
-                    error: compensateError.message
-                });
-            }
-        }
-
-        // 检查是否所有补偿都成功
-        const allSuccess = compensationResults.every(
-            r => r.success || r.reason === 'no-compensate-defined'
-        );
-
-        if (!allSuccess) {
-            this.orchestrator.logger?.error(
-                '[Saga] 部分补偿失败，需要人工介入'
-            );
-        } else {
-            this.orchestrator.logger?.info(
-                '[Saga] 所有补偿完成'
-            );
-        }
-
-        return {
-            success: allSuccess,
-            results: compensationResults
-        };
-    }
-
-    /**
-     * 生成 Saga ID
-     * @private
-     * @returns {string} Saga ID
-     */
-    _generateSagaId() {
-        return `saga_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-}
-
-module.exports = SagaExecutor;
-
-

package/lib/saga/SagaOrchestrator.js

@@ -1,186 +0,0 @@
-/**
- * Saga 协调器
- * 负责管理所有 Saga 定义
- * 支持 Redis 存储（多进程共享）或内存存储（单进程）
- */
-const SagaDefinition = require('./SagaDefinition');
-
-class SagaOrchestrator {
-    /**
-     * 构造函数
-     * @param {Object} options - 配置选项
-     * @param {Object} [options.cache] - 缓存实例（可选，Redis 或内存）
-     * @param {Object} [options.logger] - 日志记录器（可选）
-     */
-    constructor(options = {}) {
-        this.cache = options.cache;
-        this.logger = options.logger;
-
-        // 存储策略：根据 cache 配置自动选择
-        // 只有当 cache 存在且是 Redis 实例时才使用 Redis 存储
-        if (this.cache && this.cache !== false && typeof this.cache.set === 'function') {
-            // 检测是否为 Redis（通过检查特定方法）
-            const isRedis = typeof this.cache.keys === 'function' &&
-                           typeof this.cache.publish === 'function';
-
-            if (isRedis) {
-                // Redis 模式：使用 cache.set/get 存储 Saga 元数据
-                this.useRedis = true;
-                this.sagaKeyPrefix = 'monsqlize:saga:def:';
-                this.logger?.debug('[Saga] 使用 Redis 存储（多进程共享）');
-            } else {
-                // 内存缓存模式：使用 Map 存储
-                this.sagas = new Map();
-                this.useRedis = false;
-                this.logger?.debug('[Saga] 使用内存缓存（单进程，Saga 元数据不共享）');
-            }
-        } else {
-            // 内存模式：使用 Map 存储
-            this.sagas = new Map();
-            this.useRedis = false;
-            this.logger?.debug('[Saga] 使用内存存储（单进程）');
-        }
-
-        // 统计信息
-        this.stats = {
-            totalExecutions: 0,
-            successfulExecutions: 0,
-            failedExecutions: 0,
-            compensatedExecutions: 0
-        };
-    }
-
-    /**
-     * 定义 Saga
-     * @param {Object} config - Saga 配置
-     * @param {string} config.name - Saga 名称
-     * @param {Array} config.steps - Saga 步骤列表
-     * @returns {SagaDefinition} Saga 定义实例
-     */
-    async defineSaga(config) {
-        this._validateConfig(config);
-
-        const saga = new SagaDefinition(config, this);
-
-        if (this.useRedis) {
-            // 存储元数据到 Redis
-            await this.cache.set(
-                this.sagaKeyPrefix + config.name,
-                {
-                    name: config.name,
-                    steps: config.steps.map(s => ({
-                        name: s.name,
-                        hasCompensate: !!s.compensate
-                    }))
-                },
-                0  // TTL=0 永久存储
-            );
-
-            // 函数保存在内存
-            if (!this.sagas) this.sagas = new Map();
-            this.sagas.set(config.name, saga);
-        } else {
-            this.sagas.set(config.name, saga);
-        }
-
-        this.logger?.debug(`[Saga] 定义 Saga: ${config.name}`);
-        return saga;
-    }
-
-    /**
-     * 执行 Saga
-     * @param {string} sagaName - Saga 名称
-     * @param {Object} data - 执行数据
-     * @returns {Promise<Object>} 执行结果
-     */
-    async execute(sagaName, data) {
-        const saga = this.sagas?.get(sagaName);
-
-        if (!saga && this.useRedis) {
-            // 检查 Redis 中是否存在
-            const key = this.sagaKeyPrefix + sagaName;
-            const def = await this.cache.get(key);
-
-            if (def) {
-                throw new Error(
-                    `Saga '${sagaName}' 在 Redis 中存在但未在当前进程注册。` +
-                    '请在进程启动时调用 defineSaga() 注册。'
-                );
-            }
-        }
-
-        if (!saga) {
-            throw new Error(`Saga '${sagaName}' 未定义`);
-        }
-
-        this.stats.totalExecutions++;
-
-        try {
-            const result = await saga.execute(data);
-
-            if (result.success) {
-                this.stats.successfulExecutions++;
-            } else {
-                this.stats.failedExecutions++;
-                this.stats.compensatedExecutions++;
-            }
-
-            return result;
-        } catch (error) {
-            this.stats.failedExecutions++;
-            throw error;
-        }
-    }
-
-    /**
-     * 列出所有已定义的 Saga
-     * @returns {Promise<string[]>} Saga 名称列表
-     */
-    async listSagas() {
-        if (this.useRedis) {
-            const keys = await this.cache.keys(this.sagaKeyPrefix + '*');
-            return keys.map(key => key.replace(this.sagaKeyPrefix, ''));
-        } else {
-            return Array.from(this.sagas.keys());
-        }
-    }
-
-    /**
-     * 获取统计信息
-     * @returns {Object} 统计信息
-     */
-    getStats() {
-        return {
-            ...this.stats,
-            successRate: this.stats.totalExecutions > 0
-                ? ((this.stats.successfulExecutions / this.stats.totalExecutions) * 100).toFixed(2) + '%'
-                : '0%',
-            storageMode: this.useRedis ? 'Redis' : '内存'
-        };
-    }
-
-    /**
-     * 验证 Saga 配置
-     * @private
-     * @param {Object} config - Saga 配置
-     */
-    _validateConfig(config) {
-        if (!config.name) {
-            throw new Error('Saga name is required');
-        }
-
-        if (!Array.isArray(config.steps) || config.steps.length === 0) {
-            throw new Error('Saga steps must be a non-empty array');
-        }
-
-        for (const step of config.steps) {
-            if (!step.name || !step.execute) {
-                throw new Error('Each step must have name and execute function');
-            }
-        }
-    }
-}
-
-module.exports = SagaOrchestrator;
-
-

package/lib/saga/index.js

@@ -1,11 +0,0 @@
-/**
- * Saga 模块导出
- */
-module.exports = {
-    SagaOrchestrator: require('./SagaOrchestrator'),
-    SagaDefinition: require('./SagaDefinition'),
-    SagaExecutor: require('./SagaExecutor'),
-    SagaContext: require('./SagaContext')
-};
-
-

package/lib/slow-query-log/base-storage.js

@@ -1,70 +0,0 @@
-/**
- * 慢查询日志存储接口
- * 所有存储适配器必须实现此接口
- *
- * @version 1.3.0
- * @since 2025-12-22
- */
-
-class ISlowQueryLogStorage {
-  /**
-   * 初始化存储（创建集合/表、索引等）
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    throw new Error('ISlowQueryLogStorage.initialize() must be implemented');
-  }
-
-  /**
-   * 保存单条慢查询日志
-   * @param {Object} log - 慢查询日志对象
-   * @param {string} log.db - 数据库名
-   * @param {string} log.collection - 集合名
-   * @param {string} log.operation - 操作类型
-   * @param {Object} log.queryShape - 查询模式（已脱敏）
-   * @param {number} log.executionTimeMs - 执行时间（毫秒）
-   * @param {Date} log.timestamp - 时间戳
-   * @param {Object} [log.metadata] - 扩展元数据
-   * @returns {Promise<void>}
-   */
-  async save(log) {
-    throw new Error('ISlowQueryLogStorage.save() must be implemented');
-  }
-
-  /**
-   * 批量保存慢查询日志
-   * @param {Object[]} logs - 慢查询日志数组
-   * @returns {Promise<void>}
-   */
-  async saveBatch(logs) {
-    throw new Error('ISlowQueryLogStorage.saveBatch() must be implemented');
-  }
-
-  /**
-   * 查询慢查询日志
-   * @param {Object} filter - 查询条件
-   * @param {string} [filter.db] - 数据库名
-   * @param {string} [filter.collection] - 集合名
-   * @param {string} [filter.operation] - 操作类型
-   * @param {Object} options - 查询选项
-   * @param {Object} [options.sort] - 排序规则
-   * @param {number} [options.limit] - 限制数量
-   * @param {number} [options.skip] - 跳过数量
-   * @returns {Promise<Object[]>}
-   */
-  async query(filter, options) {
-    throw new Error('ISlowQueryLogStorage.query() must be implemented');
-  }
-
-  /**
-   * 关闭连接
-   * @returns {Promise<void>}
-   */
-  async close() {
-    throw new Error('ISlowQueryLogStorage.close() must be implemented');
-  }
-}
-
-module.exports = { ISlowQueryLogStorage };
-
-

package/lib/slow-query-log/batch-queue.js

@@ -1,97 +0,0 @@
-/**
- * 批量队列管理器
- * 用于批量写入慢查询日志，优化性能
- *
- * @version 1.3.0
- * @since 2025-12-22
- */
-
-class BatchQueue {
-  /**
-   * 创建批量队列
-   * @param {Object} storage - 存储适配器实例
-   * @param {Object} options - 队列配置
-   * @param {number} [options.batchSize=10] - 批量大小
-   * @param {number} [options.flushInterval=5000] - 刷新间隔（毫秒）
-   * @param {number} [options.maxBufferSize=100] - 最大缓冲区大小
-   * @param {Object} [logger] - 日志记录器
-   */
-  constructor(storage, options = {}, logger) {
-    this.storage = storage;
-    this.buffer = [];
-    this.batchSize = options.batchSize || 10;
-    this.flushInterval = options.flushInterval || 5000;
-    this.maxBufferSize = options.maxBufferSize || 100;
-    this.timer = null;
-    this.flushing = false;
-    this.logger = logger || console;
-  }
-
-  /**
-   * 添加日志到队列
-   * @param {Object} log - 慢查询日志对象
-   * @returns {Promise<void>}
-   */
-  async add(log) {
-    this.buffer.push(log);
-
-    // 防止内存溢出：达到最大缓冲区，立即刷新
-    if (this.buffer.length >= this.maxBufferSize) {
-      await this.flush();
-      return;
-    }
-
-    // 达到批量大小，立即刷新
-    if (this.buffer.length >= this.batchSize) {
-      await this.flush();
-    } else if (!this.timer) {
-      // 启动定时器（防止数据积压）
-      this.timer = setTimeout(() => this.flush(), this.flushInterval);
-    }
-  }
-
-  /**
-   * 刷新队列（批量写入）
-   * @returns {Promise<void>}
-   */
-  async flush() {
-    // 防止并发刷新
-    if (this.flushing || this.buffer.length === 0) {
-      return;
-    }
-
-    this.flushing = true;
-    const logs = this.buffer.splice(0);  // 清空缓冲区
-    clearTimeout(this.timer);
-    this.timer = null;
-
-    try {
-      // 批量写入
-      await this.storage.saveBatch(logs);
-      if (this.logger.debug) {
-        this.logger.debug(`[SlowQueryLog] Batch flushed: ${logs.length} logs`);
-      }
-    } catch (err) {
-      // ⚠️ 失败不阻塞主流程，仅记录错误
-      if (this.logger.error) {
-        this.logger.error('[SlowQueryLog] Failed to save slow query logs batch:', err);
-      }
-    } finally {
-      this.flushing = false;
-    }
-  }
-
-  /**
-   * 关闭队列（确保数据不丢失）
-   * @returns {Promise<void>}
-   */
-  async close() {
-    clearTimeout(this.timer);
-    this.timer = null;
-    await this.flush();  // 最后刷新一次
-  }
-}
-
-module.exports = { BatchQueue };
-
-