monsqlize 1.3.0 → 2.0.0

package/lib/infrastructure/HealthChecker.js

@@ -1,281 +0,0 @@
-/**
- * HealthChecker - 连接池健康检查器
- *
- * 定期检查连接池健康状态，自动标记 up/down
- * 支持故障检测和自动恢复
- *
- * @module lib/infrastructure/HealthChecker
- * @since v1.0.8
- */
-
-/**
- * 健康状态
- * @typedef {Object} HealthStatus
- * @property {'up'|'down'|'checking'} status - 状态
- * @property {Date} lastCheck - 最后检查时间
- * @property {Error} [lastError] - 最后错误
- * @property {number} consecutiveFailures - 连续失败次数
- */
-
-/**
- * 健康检查器
- */
-class HealthChecker {
-    /**
-     * 构造函数
-     *
-     * @param {Object} options - 配置选项
-     * @param {ConnectionPoolManager} options.poolManager - 连接池管理器
-     * @param {Object} options.logger - 日志记录器
-     */
-    constructor(options = {}) {
-        this._poolManager = options.poolManager;
-        this._logger = options.logger || console;
-
-        this._healthStatus = new Map(); // Map<poolName, HealthStatus>
-        this._checkConfigs = new Map(); // Map<poolName, CheckConfig>
-        this._intervals = new Map();    // Map<poolName, NodeJS.Timeout>
-
-        this._started = false;
-    }
-
-    /**
-     * 注册连接池
-     *
-     * @param {string} poolName - 连接池名称
-     * @param {Object} config - 健康检查配置
-     */
-    register(poolName, config) {
-        this._checkConfigs.set(poolName, config);
-
-        // 初始化健康状态
-        this._healthStatus.set(poolName, {
-            status: 'up',
-            lastCheck: new Date(),
-            consecutiveFailures: 0
-        });
-
-        // 如果已启动，立即开始检查
-        if (this._started) {
-            this._startCheckForPool(poolName, config);
-        }
-    }
-
-    /**
-     * 注销连接池
-     *
-     * @param {string} poolName - 连接池名称
-     */
-    unregister(poolName) {
-        // 停止检查
-        this._stopCheckForPool(poolName);
-
-        // 删除状态和配置
-        this._healthStatus.delete(poolName);
-        this._checkConfigs.delete(poolName);
-    }
-
-    /**
-     * 启动所有健康检查
-     */
-    start() {
-        if (this._started) {
-            return;
-        }
-
-        this._started = true;
-
-        // 为所有已注册的连接池启动检查
-        for (const [poolName, config] of this._checkConfigs.entries()) {
-            this._startCheckForPool(poolName, config);
-        }
-
-        this._logger.info('[HealthChecker] 健康检查已启动');
-    }
-
-    /**
-     * 停止所有健康检查
-     */
-    stop() {
-        if (!this._started) {
-            return;
-        }
-
-        this._started = false;
-
-        // 停止所有检查
-        for (const poolName of this._intervals.keys()) {
-            this._stopCheckForPool(poolName);
-        }
-
-        this._logger.info('[HealthChecker] 健康检查已停止');
-    }
-
-    /**
-     * 为单个连接池启动检查
-     *
-     * @private
-     */
-    _startCheckForPool(poolName, config) {
-        // 清除现有定时器
-        this._stopCheckForPool(poolName);
-
-        // 创建新定时器
-        const interval = setInterval(async () => {
-            await this._checkPool(poolName, config);
-        }, config.interval);
-
-        this._intervals.set(poolName, interval);
-
-        // 立即执行一次检查
-        setImmediate(async () => {
-            await this._checkPool(poolName, config);
-        });
-    }
-
-    /**
-     * 为单个连接池停止检查
-     *
-     * @private
-     */
-    _stopCheckForPool(poolName) {
-        const interval = this._intervals.get(poolName);
-        if (interval) {
-            clearInterval(interval);
-            this._intervals.delete(poolName);
-        }
-    }
-
-    /**
-     * 检查单个连接池
-     *
-     * @private
-     */
-    async _checkPool(poolName, config) {
-        const status = this._healthStatus.get(poolName);
-        if (!status) {
-            return;
-        }
-
-        // 更新状态为检查中
-        status.status = 'checking';
-        status.lastCheck = new Date();
-
-        const retries = config.retries || 3;
-        let success = false;
-        let lastError = null;
-
-        // 重试机制
-        for (let attempt = 0; attempt < retries; attempt++) {
-            try {
-                const isHealthy = await this._pingPool(poolName, config.timeout);
-                if (isHealthy) {
-                    success = true;
-                    break;
-                }
-            } catch (error) {
-                lastError = error;
-            }
-
-            // 等待后重试
-            if (attempt < retries - 1) {
-                await this._sleep(1000);
-            }
-        }
-
-        if (success) {
-            // 健康检查成功
-            const wasDown = status.status === 'down';
-
-            status.status = 'up';
-            status.consecutiveFailures = 0;
-            delete status.lastError;
-
-            if (wasDown) {
-                this._logger.info(`[HealthChecker] 连接池已恢复: ${poolName}`);
-                // TODO: 触发 onPoolUp 事件
-            }
-        } else {
-            // 健康检查失败
-            status.consecutiveFailures++;
-            status.lastError = lastError;
-
-            // 连续失败达到阈值，标记为 down
-            if (status.consecutiveFailures >= retries) {
-                const wasUp = status.status === 'up';
-
-                status.status = 'down';
-
-                if (wasUp) {
-                    this._logger.warn(`[HealthChecker] 连接池已故障: ${poolName}`, {
-                        consecutiveFailures: status.consecutiveFailures,
-                        error: lastError?.message
-                    });
-                    // TODO: 触发 onPoolDown 事件
-                }
-            }
-        }
-    }
-
-    /**
-     * Ping 连接池
-     *
-     * @private
-     * @param {string} poolName - 连接池名称
-     * @param {number} timeout - 超时时间
-     * @returns {Promise<boolean>}
-     */
-    async _pingPool(poolName, timeout) {
-        const client = this._poolManager._getPool(poolName);
-        if (!client) {
-            return false;
-        }
-
-        try {
-            // 使用 Promise.race 实现超时
-            const pingPromise = client.db('admin').command({ ping: 1 });
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Ping timeout')), timeout);
-            });
-
-            await Promise.race([pingPromise, timeoutPromise]);
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    /**
-     * 获取连接池健康状态
-     *
-     * @param {string} poolName - 连接池名称
-     * @returns {HealthStatus|null}
-     */
-    getStatus(poolName) {
-        return this._healthStatus.get(poolName) || null;
-    }
-
-    /**
-     * 获取所有健康状态
-     *
-     * @returns {Map<string, HealthStatus>}
-     */
-    getAllStatus() {
-        return new Map(this._healthStatus);
-    }
-
-    /**
-     * 睡眠
-     *
-     * @private
-     * @param {number} ms - 毫秒
-     * @returns {Promise<void>}
-     */
-    _sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}
-
-module.exports = HealthChecker;
-
-

package/lib/infrastructure/PoolConfig.js

@@ -1,199 +0,0 @@
-/**
- * PoolConfig - 连接池配置验证器
- *
- * 验证连接池配置的有效性
- *
- * @module lib/infrastructure/PoolConfig
- * @since v1.0.8
- */
-
-/**
- * 验证连接池配置
- *
- * @param {Object} config - 连接池配置
- * @throws {Error} 如果配置无效
- */
-function validatePoolConfig(config) {
-    if (!config || typeof config !== 'object') {
-        throw new Error('Pool config must be an object');
-    }
-
-    // 必需字段
-    if (!config.name || typeof config.name !== 'string') {
-        throw new Error('Pool config.name is required and must be a string');
-    }
-
-    if (!config.uri || typeof config.uri !== 'string') {
-        throw new Error('Pool config.uri is required and must be a string');
-    }
-
-    // 验证 URI 格式
-    if (!config.uri.startsWith('mongodb://') && !config.uri.startsWith('mongodb+srv://')) {
-        throw new Error('Pool config.uri must start with mongodb:// or mongodb+srv://');
-    }
-
-    // 验证 role
-    if (config.role) {
-        const validRoles = ['primary', 'secondary', 'analytics', 'custom'];
-        if (!validRoles.includes(config.role)) {
-            throw new Error(`Pool config.role must be one of: ${validRoles.join(', ')}`);
-        }
-    }
-
-    // 验证 weight
-    if (config.weight !== undefined) {
-        if (typeof config.weight !== 'number' || config.weight < 0) {
-            throw new Error('Pool config.weight must be a non-negative number');
-        }
-    }
-
-    // 验证 options
-    if (config.options) {
-        if (typeof config.options !== 'object') {
-            throw new Error('Pool config.options must be an object');
-        }
-
-        // 验证数值选项
-        const numericOptions = [
-            'maxPoolSize',
-            'minPoolSize',
-            'maxIdleTimeMS',
-            'waitQueueTimeoutMS',
-            'connectTimeoutMS',
-            'serverSelectionTimeoutMS'
-        ];
-
-        for (const key of numericOptions) {
-            if (config.options[key] !== undefined) {
-                if (typeof config.options[key] !== 'number' || config.options[key] < 0) {
-                    throw new Error(`Pool config.options.${key} must be a non-negative number`);
-                }
-            }
-        }
-    }
-
-    // 验证 healthCheck
-    if (config.healthCheck) {
-        if (typeof config.healthCheck !== 'object') {
-            throw new Error('Pool config.healthCheck must be an object');
-        }
-
-        if (config.healthCheck.enabled !== undefined && typeof config.healthCheck.enabled !== 'boolean') {
-            throw new Error('Pool config.healthCheck.enabled must be a boolean');
-        }
-
-        const numericHealthOptions = ['interval', 'timeout', 'retries'];
-        for (const key of numericHealthOptions) {
-            if (config.healthCheck[key] !== undefined) {
-                if (typeof config.healthCheck[key] !== 'number' || config.healthCheck[key] < 0) {
-                    throw new Error(`Pool config.healthCheck.${key} must be a non-negative number`);
-                }
-            }
-        }
-    }
-
-    // 验证 tags
-    if (config.tags) {
-        if (!Array.isArray(config.tags)) {
-            throw new Error('Pool config.tags must be an array');
-        }
-
-        for (const tag of config.tags) {
-            if (typeof tag !== 'string') {
-                throw new Error('Pool config.tags must be an array of strings');
-            }
-        }
-    }
-}
-
-/**
- * 验证连接池配置（返回错误数组）
- *
- * @param {Object} config - 连接池配置
- * @returns {Array<string>} 错误消息数组，空数组表示验证通过
- */
-function validate(config) {
-    const errors = [];
-
-    if (!config || typeof config !== 'object') {
-        errors.push('Pool config must be an object');
-        return errors;
-    }
-
-    // 必需字段
-    if (!config.name || typeof config.name !== 'string') {
-        errors.push('Pool config.name is required and must be a string');
-    }
-
-    if (!config.uri || typeof config.uri !== 'string') {
-        errors.push('Pool config.uri is required and must be a string');
-    } else {
-        // 验证 URI 格式
-        if (!config.uri.startsWith('mongodb://') && !config.uri.startsWith('mongodb+srv://')) {
-            errors.push('Pool config.uri must start with mongodb:// or mongodb+srv://');
-        }
-    }
-
-    // 验证 role
-    if (config.role) {
-        const validRoles = ['primary', 'secondary', 'analytics', 'custom'];
-        if (!validRoles.includes(config.role)) {
-            errors.push(`Pool config.role must be one of: ${validRoles.join(', ')}`);
-        }
-    }
-
-    // 验证 weight
-    if (config.weight !== undefined) {
-        if (typeof config.weight !== 'number' || config.weight < 0) {
-            errors.push('Pool config.weight must be a non-negative number');
-        }
-    }
-
-    // 验证 options
-    if (config.options && typeof config.options !== 'object') {
-        errors.push('Pool config.options must be an object');
-    }
-
-    // 验证 healthCheck
-    if (config.healthCheck) {
-        if (typeof config.healthCheck !== 'object') {
-            errors.push('Pool config.healthCheck must be an object');
-        } else {
-            if (config.healthCheck.enabled !== undefined && typeof config.healthCheck.enabled !== 'boolean') {
-                errors.push('Pool config.healthCheck.enabled must be a boolean');
-            }
-
-            const numericHealthOptions = ['interval', 'timeout', 'retries'];
-            for (const key of numericHealthOptions) {
-                if (config.healthCheck[key] !== undefined) {
-                    if (typeof config.healthCheck[key] !== 'number' || config.healthCheck[key] < 0) {
-                        errors.push(`Pool config.healthCheck.${key} must be a non-negative number`);
-                    }
-                }
-            }
-        }
-    }
-
-    // 验证 tags
-    if (config.tags) {
-        if (!Array.isArray(config.tags)) {
-            errors.push('Pool config.tags must be an array');
-        } else {
-            for (const tag of config.tags) {
-                if (typeof tag !== 'string') {
-                    errors.push('Pool config.tags must be an array of strings');
-                    break;
-                }
-            }
-        }
-    }
-
-    return errors;
-}
-
-module.exports = {
-    validatePoolConfig,
-    validate
-};
-
-

package/lib/infrastructure/PoolSelector.js

@@ -1,225 +0,0 @@
-/**
- * PoolSelector - 连接池智能选择器
- *
- * 根据策略选择合适的连接池
- * 支持：auto（自动）、roundRobin（轮询）、leastConnections（最少连接）、
- *      weighted（加权）、manual（手动）
- *
- * @module lib/infrastructure/PoolSelector
- * @since v1.0.8
- */
-
-/**
- * 连接池选择器
- */
-class PoolSelector {
-    /**
-     * 构造函数
-     *
-     * @param {Object} options - 配置选项
-     * @param {string} options.strategy - 选择策略
-     * @param {Object} options.logger - 日志记录器
-     */
-    constructor(options = {}) {
-        this._strategy = options.strategy || 'auto';
-        this._logger = options.logger || console;
-        this._roundRobinIndex = new Map(); // 轮询索引 Map<role, number>
-    }
-
-    /**
-     * 选择连接池
-     *
-     * @param {Array<PoolConfig>} pools - 候选连接池列表
-     * @param {Object} context - 上下文
-     * @param {string} context.operation - 操作类型 ('read' | 'write')
-     * @param {Map} context.healthStatus - 健康状态
-     * @param {Object} context.stats - 统计信息
-     * @param {Object} [context.poolPreference] - 连接池偏好
-     * @returns {string} 选中的连接池名称
-     * @throws {Error} 如果无可用连接池
-     */
-    select(pools, context) {
-        if (!pools || pools.length === 0) {
-            throw new Error('No available pools');
-        }
-
-        // 根据策略选择
-        switch (this._strategy) {
-            case 'auto':
-                return this._selectByAuto(pools, context);
-
-            case 'roundRobin':
-                return this._selectByRoundRobin(pools, context);
-
-            case 'leastConnections':
-                return this._selectByLeastConnections(pools, context);
-
-            case 'weighted':
-                return this._selectByWeighted(pools, context);
-
-            case 'manual':
-                // 手动模式不应该到这里（应该在 ConnectionPoolManager 处理）
-                return pools[0].name;
-
-            default:
-                this._logger.warn(`[PoolSelector] 未知策略: ${this._strategy}，使用 auto`);
-                return this._selectByAuto(pools, context);
-        }
-    }
-
-    /**
-     * 自动策略：读写分离 + 负载均衡
-     *
-     * @private
-     */
-    _selectByAuto(pools, context) {
-        const { operation, poolPreference } = context;
-
-        // 1. 根据操作类型过滤
-        let candidates = pools;
-
-        if (operation === 'read') {
-            // 读操作优先使用 secondary
-            const secondaries = pools.filter(p => p.role === 'secondary');
-            if (secondaries.length > 0) {
-                candidates = secondaries;
-            }
-        } else if (operation === 'write') {
-            // 写操作优先使用 primary
-            const primaries = pools.filter(p => p.role === 'primary');
-            if (primaries.length > 0) {
-                candidates = primaries;
-            }
-        }
-
-        // 2. 根据 poolPreference 过滤
-        if (poolPreference) {
-            if (poolPreference.role) {
-                const filtered = candidates.filter(p => p.role === poolPreference.role);
-                if (filtered.length > 0) {
-                    candidates = filtered;
-                }
-            }
-
-            if (poolPreference.tags && poolPreference.tags.length > 0) {
-                const filtered = candidates.filter(p => {
-                    if (!p.tags) return false;
-                    return poolPreference.tags.some(tag => p.tags.includes(tag));
-                });
-                if (filtered.length > 0) {
-                    candidates = filtered;
-                }
-            }
-        }
-
-        // 3. 如果只剩一个，直接返回
-        if (candidates.length === 1) {
-            return candidates[0].name;
-        }
-
-        // 4. 多个候选，使用加权负载均衡
-        return this._selectByWeighted(candidates, context);
-    }
-
-    /**
-     * 轮询策略
-     *
-     * @private
-     */
-    _selectByRoundRobin(pools, context) {
-        const { operation } = context;
-        const key = operation || 'default';
-
-        // 获取当前索引
-        let index = this._roundRobinIndex.get(key) || 0;
-
-        // 选择连接池
-        const pool = pools[index % pools.length];
-
-        // 更新索引
-        this._roundRobinIndex.set(key, (index + 1) % pools.length);
-
-        return pool.name;
-    }
-
-    /**
-     * 最少连接策略
-     *
-     * @private
-     */
-    _selectByLeastConnections(pools, context) {
-        const { stats } = context;
-
-        if (!stats) {
-            // 无统计信息，降级到轮询
-            return this._selectByRoundRobin(pools, context);
-        }
-
-        let minConnections = Infinity;
-        let selectedPool = pools[0];
-
-        for (const pool of pools) {
-            const poolStats = stats[pool.name];
-            if (!poolStats) continue;
-
-            const connections = poolStats.connections || 0;
-            if (connections < minConnections) {
-                minConnections = connections;
-                selectedPool = pool;
-            }
-        }
-
-        return selectedPool.name;
-    }
-
-    /**
-     * 加权策略
-     *
-     * @private
-     */
-    _selectByWeighted(pools, context) {
-        // 计算总权重
-        let totalWeight = 0;
-        for (const pool of pools) {
-            totalWeight += (pool.weight || 1);
-        }
-
-        // 随机选择
-        let random = Math.random() * totalWeight;
-
-        for (const pool of pools) {
-            const weight = pool.weight || 1;
-            random -= weight;
-
-            if (random <= 0) {
-                return pool.name;
-            }
-        }
-
-        // 降级（不应该到这里）
-        return pools[0].name;
-    }
-
-    /**
-     * 设置策略
-     *
-     * @param {string} strategy - 策略名称
-     */
-    setStrategy(strategy) {
-        this._strategy = strategy;
-        this._logger.info(`[PoolSelector] 策略已更改: ${strategy}`);
-    }
-
-    /**
-     * 获取当前策略
-     *
-     * @returns {string}
-     */
-    getStrategy() {
-        return this._strategy;
-    }
-}
-
-module.exports = PoolSelector;
-
-