monsqlize 1.3.0 → 2.0.0

package/lib/sync/SyncConfig.js

@@ -1,127 +0,0 @@
-/**
- * SyncConfig - 同步配置验证
- *
- * 负责验证和规范化 Change Stream 同步配置
- *
- * @module lib/sync/SyncConfig
- * @since v1.0.8
- */
-
-/**
- * 验证同步配置
- *
- * @param {Object} config - 同步配置
- * @param {boolean} config.enabled - 是否启用同步
- * @param {Array} config.targets - 备份目标数组
- * @param {Object} [config.resumeToken] - Resume Token 配置
- * @param {Function} [config.filter] - 过滤函数
- * @param {Function} [config.transform] - 转换函数
- * @throws {Error} 配置无效时抛出错误
- */
-function validateSyncConfig(config) {
-    if (!config || typeof config !== 'object') {
-        throw new Error('[Sync] 配置必须是对象');
-    }
-
-    // 验证 enabled
-    if (typeof config.enabled !== 'boolean') {
-        throw new Error('[Sync] enabled 必须是 boolean 类型');
-    }
-
-    // 如果未启用，不需要验证其他配置
-    if (!config.enabled) {
-        return;
-    }
-
-    // 验证 targets
-    if (!Array.isArray(config.targets) || config.targets.length === 0) {
-        throw new Error('[Sync] targets 必须是非空数组');
-    }
-
-    // 验证每个 target
-    config.targets.forEach((target, index) => {
-        validateTargetConfig(target, index);
-    });
-
-    // 验证 resumeToken（可选）
-    if (config.resumeToken) {
-        validateResumeTokenConfig(config.resumeToken);
-    }
-
-    // 验证 filter（可选）
-    if (config.filter && typeof config.filter !== 'function') {
-        throw new Error('[Sync] filter 必须是函数');
-    }
-
-    // 验证 transform（可选）
-    if (config.transform && typeof config.transform !== 'function') {
-        throw new Error('[Sync] transform 必须是函数');
-    }
-}
-
-/**
- * 验证备份目标配置
- *
- * @param {Object} target - 目标配置
- * @param {number} index - 索引（用于错误提示）
- */
-function validateTargetConfig(target, index) {
-    if (!target || typeof target !== 'object') {
-        throw new Error(`[Sync] targets[${index}] 必须是对象`);
-    }
-
-    // 验证 name
-    if (!target.name || typeof target.name !== 'string') {
-        throw new Error(`[Sync] targets[${index}].name 必须是非空字符串`);
-    }
-
-    // 验证 uri
-    if (!target.uri || typeof target.uri !== 'string') {
-        throw new Error(`[Sync] targets[${index}].uri 必须是非空字符串`);
-    }
-
-    // 验证 collections（可选）
-    if (target.collections) {
-        if (!Array.isArray(target.collections)) {
-            throw new Error(`[Sync] targets[${index}].collections 必须是数组`);
-        }
-        if (target.collections.length === 0) {
-            throw new Error(`[Sync] targets[${index}].collections 不能为空数组`);
-        }
-    }
-}
-
-/**
- * 验证 Resume Token 配置
- *
- * @param {Object} config - Resume Token 配置
- */
-function validateResumeTokenConfig(config) {
-    if (!config || typeof config !== 'object') {
-        throw new Error('[Sync] resumeToken 必须是对象');
-    }
-
-    // 验证 storage
-    const validStorages = ['file', 'redis'];
-    if (config.storage && !validStorages.includes(config.storage)) {
-        throw new Error(`[Sync] resumeToken.storage 必须是 ${validStorages.join(' 或 ')}`);
-    }
-
-    // 验证 path（文件模式）
-    if (config.storage === 'file' && config.path && typeof config.path !== 'string') {
-        throw new Error('[Sync] resumeToken.path 必须是字符串');
-    }
-
-    // 验证 redis（Redis 模式）
-    if (config.storage === 'redis' && config.redis && typeof config.redis !== 'object') {
-        throw new Error('[Sync] resumeToken.redis 必须是对象');
-    }
-}
-
-module.exports = {
-    validateSyncConfig,
-    validateTargetConfig,
-    validateResumeTokenConfig
-};
-
-

package/lib/sync/SyncTarget.js

@@ -1,240 +0,0 @@
-/**
- * SyncTarget - 备份目标
- *
- * 负责连接备份数据库并执行同步操作
- * 复用 ConnectionPoolManager 管理连接
- *
- * @module lib/sync/SyncTarget
- * @since v1.0.8
- */
-
-/**
- * 同步目标类
- */
-class SyncTarget {
-    /**
-     * 构造函数
-     *
-     * @param {Object} options - 配置选项
-     * @param {string} options.name - 目标名称
-     * @param {Object} options.poolManager - ConnectionPoolManager 实例
-     * @param {Object} options.config - 目标配置
-     * @param {string} options.config.uri - MongoDB URI
-     * @param {Array} [options.config.collections] - 同步的集合列表
-     * @param {Object} [options.config.healthCheck] - 健康检查配置
-     * @param {Object} [options.logger] - 日志记录器
-     */
-    constructor(options) {
-        this.name = options.name;
-        this.poolManager = options.poolManager;
-        this.config = options.config;
-        this.logger = options.logger || console;
-
-        this.client = null;
-        this.db = null;
-        this.collections = new Map();  // 缓存 collection 对象
-
-        this.stats = {
-            syncCount: 0,
-            errorCount: 0,
-            lastSyncTime: null,
-            lastError: null
-        };
-    }
-
-    /**
-     * 连接备份数据库
-     *
-     * 复用 ConnectionPoolManager，将备份库添加为连接池
-     *
-     * @returns {Promise<void>}
-     */
-    async connect() {
-        try {
-            // 🔴 关键：将备份库添加到 ConnectionPoolManager
-            await this.poolManager.addPool({
-                name: this.name,
-                uri: this.config.uri,
-                role: 'backup',  // 标记为备份角色
-                healthCheck: this.config.healthCheck || {
-                    enabled: true,
-                    interval: 30000,  // 30秒检查一次
-                    timeout: 5000,
-                    retries: 3
-                }
-            });
-
-            // 获取连接
-            const pool = this.poolManager.getPool(this.name);
-            this.client = pool.client;
-            this.db = this.client.db();
-
-            this.logger.info('[SyncTarget] 备份库已连接', {
-                name: this.name,
-                uri: this._maskUri(this.config.uri)
-            });
-
-        } catch (error) {
-            this.logger.error('[SyncTarget] 连接备份库失败', {
-                name: this.name,
-                error: error.message
-            });
-            throw error;
-        }
-    }
-
-    /**
-     * 应用同步操作
-     *
-     * @param {string} operationType - 操作类型 ('insert' | 'update' | 'replace' | 'delete')
-     * @param {Object} document - 文档对象
-     * @param {Object} documentKey - 文档键 { _id, ns }
-     * @returns {Promise<void>}
-     */
-    async apply(operationType, document, documentKey) {
-        const collectionName = documentKey?.ns?.coll || this.config.collection;
-
-        if (!collectionName) {
-            this.logger.warn('[SyncTarget] 无法确定集合名称', {
-                target: this.name,
-                documentKey
-            });
-            return;
-        }
-
-        const collection = this._getCollection(collectionName);
-
-        try {
-            switch (operationType) {
-                case 'insert':
-                    await collection.insertOne(document);
-                    break;
-
-                case 'update':
-                case 'replace':
-                    // 使用 replaceOne + upsert 确保数据一致
-                    await collection.replaceOne(
-                        { _id: documentKey._id },
-                        document,
-                        { upsert: true }
-                    );
-                    break;
-
-                case 'delete':
-                    await collection.deleteOne({ _id: documentKey._id });
-                    break;
-
-                default:
-                    this.logger.warn('[SyncTarget] 未知操作类型', {
-                        target: this.name,
-                        operationType
-                    });
-                    return;
-            }
-
-            // 更新统计
-            this.stats.syncCount++;
-            this.stats.lastSyncTime = new Date();
-
-            this.logger.debug('[SyncTarget] 同步成功', {
-                target: this.name,
-                operation: operationType,
-                collection: collectionName,
-                id: documentKey._id
-            });
-
-        } catch (error) {
-            // 更新统计
-            this.stats.errorCount++;
-            this.stats.lastError = {
-                time: new Date(),
-                message: error.message,
-                operation: operationType,
-                collection: collectionName
-            };
-
-            this.logger.error('[SyncTarget] 同步失败', {
-                target: this.name,
-                operation: operationType,
-                collection: collectionName,
-                error: error.message,
-                code: error.code
-            });
-
-            // 抛出错误，由 ChangeStreamSyncManager 处理
-            throw error;
-        }
-    }
-
-    /**
-     * 获取 Collection 对象（带缓存）
-     *
-     * @private
-     * @param {string} name - 集合名称
-     * @returns {Object} MongoDB Collection 对象
-     */
-    _getCollection(name) {
-        if (!this.collections.has(name)) {
-            this.collections.set(name, this.db.collection(name));
-        }
-        return this.collections.get(name);
-    }
-
-    /**
-     * 掩码 URI（隐藏密码）
-     *
-     * @private
-     * @param {string} uri - MongoDB URI
-     * @returns {string} 掩码后的 URI
-     */
-    _maskUri(uri) {
-        try {
-            return uri.replace(/:([^:@]+)@/, ':***@');
-        } catch (error) {
-            return uri;
-        }
-    }
-
-    /**
-     * 获取统计信息
-     *
-     * @returns {Object} 统计信息
-     */
-    getStats() {
-        return {
-            name: this.name,
-            syncCount: this.stats.syncCount,
-            errorCount: this.stats.errorCount,
-            lastSyncTime: this.stats.lastSyncTime,
-            lastError: this.stats.lastError,
-            successRate: this.stats.syncCount > 0
-                ? ((this.stats.syncCount - this.stats.errorCount) / this.stats.syncCount * 100).toFixed(2) + '%'
-                : '0%'
-        };
-    }
-
-    /**
-     * 关闭连接
-     *
-     * @returns {Promise<void>}
-     */
-    async close() {
-        try {
-            if (this.poolManager && this.name) {
-                await this.poolManager.removePool(this.name);
-                this.logger.info('[SyncTarget] 备份库连接已关闭', {
-                    name: this.name
-                });
-            }
-        } catch (error) {
-            this.logger.warn('[SyncTarget] 关闭连接失败', {
-                name: this.name,
-                error: error.message
-            });
-        }
-    }
-}
-
-module.exports = SyncTarget;
-
-

package/lib/sync/index.js

@@ -1,20 +0,0 @@
-/**
- * Sync 模块导出
- *
- * @module lib/sync
- * @since v1.0.9
- */
-
-const ChangeStreamSyncManager = require('./ChangeStreamSyncManager');
-const SyncTarget = require('./SyncTarget');
-const ResumeTokenStore = require('./ResumeTokenStore');
-const { validateSyncConfig } = require('./SyncConfig');
-
-module.exports = {
-    ChangeStreamSyncManager,
-    SyncTarget,
-    ResumeTokenStore,
-    validateSyncConfig
-};
-
-

package/lib/transaction/CacheLockManager.js

@@ -1,162 +0,0 @@
-/**
- * 缓存锁管理器
- * 用于在事务执行期间锁定缓存键，防止脏数据写入缓存
- */
-
-class CacheLockManager {
-    constructor(options = {}) {
-        this.locks = new Map(); // key -> { sessionId, expiresAt }
-        this.maxDuration = options.maxDuration || 300000; // 5分钟默认
-        this.lockCleanupInterval = options.lockCleanupInterval || 10000; // 10秒清理一次
-        this.cleanupTimer = null;
-
-        // 启动自动清理
-        this._startCleanup();
-    }
-
-    /**
-     * 添加缓存锁
-     * @param {string} key - 缓存键（支持通配符 *）
-     * @param {Object} session - MongoDB session 对象
-     */
-    addLock(key, session) {
-        if (!session || !session.id) {
-            return;
-        }
-
-        const sessionId = session.id.toString();
-        const expiresAt = Date.now() + this.maxDuration;
-
-        this.locks.set(key, {
-            sessionId,
-            expiresAt,
-            lockedAt: Date.now()
-        });
-    }
-
-    /**
-     * 检查缓存键是否被锁定
-     * @param {string} key - 缓存键
-     * @returns {boolean}
-     */
-    isLocked(key) {
-        // 精确匹配
-        if (this.locks.has(key)) {
-            const lock = this.locks.get(key);
-            if (Date.now() < lock.expiresAt) {
-                return true;
-            }
-            // 过期自动删除
-            this.locks.delete(key);
-        }
-
-        // 通配符匹配
-        for (const [lockKey, lock] of this.locks.entries()) {
-            if (lockKey.includes('*')) {
-                const pattern = lockKey.replace(/\*/g, '.*');
-                const regex = new RegExp(`^${pattern}$`);
-                if (regex.test(key)) {
-                    if (Date.now() < lock.expiresAt) {
-                        return true;
-                    }
-                    // 过期自动删除
-                    this.locks.delete(lockKey);
-                }
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * 释放指定 session 的所有锁
-     * @param {Object} session - MongoDB session 对象
-     */
-    releaseLocks(session) {
-        if (!session || !session.id) {
-            return;
-        }
-
-        const sessionId = session.id.toString();
-        const keysToDelete = [];
-
-        for (const [key, lock] of this.locks.entries()) {
-            if (lock.sessionId === sessionId) {
-                keysToDelete.push(key);
-            }
-        }
-
-        keysToDelete.forEach(key => this.locks.delete(key));
-    }
-
-    /**
-     * 清理过期的锁
-     * @private
-     */
-    _cleanupExpiredLocks() {
-        const now = Date.now();
-        const keysToDelete = [];
-
-        for (const [key, lock] of this.locks.entries()) {
-            if (now >= lock.expiresAt) {
-                keysToDelete.push(key);
-            }
-        }
-
-        if (keysToDelete.length > 0) {
-            keysToDelete.forEach(key => this.locks.delete(key));
-        }
-    }
-
-    /**
-     * 启动自动清理定时器
-     * @private
-     */
-    _startCleanup() {
-        if (this.cleanupTimer) {
-            return;
-        }
-
-        this.cleanupTimer = setInterval(() => {
-            this._cleanupExpiredLocks();
-        }, this.lockCleanupInterval);
-
-        // 防止定时器阻止进程退出
-        if (this.cleanupTimer.unref) {
-            this.cleanupTimer.unref();
-        }
-    }
-
-    /**
-     * 停止自动清理
-     */
-    stop() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-    }
-
-    /**
-     * 获取当前锁的统计信息
-     */
-    getStats() {
-        return {
-            totalLocks: this.locks.size,
-            activeLocks: Array.from(this.locks.values()).filter(
-                lock => Date.now() < lock.expiresAt
-            ).length
-        };
-    }
-
-    /**
-     * 清除所有锁（用于测试）
-     */
-    clear() {
-        this.locks.clear();
-    }
-}
-
-module.exports = CacheLockManager;
-
-