monsqlize 1.3.0 → 2.0.0

package/lib/infrastructure/PoolStats.js

@@ -1,244 +0,0 @@
-/**
- * PoolStats - 连接池统计收集器
- *
- * 收集连接池的统计信息（连接数、响应时间、请求数等）
- * 🔴 修复问题6：使用异步批量更新提升性能
- *
- * @module lib/infrastructure/PoolStats
- * @since v1.0.8
- */
-
-/**
- * 统计收集器
- */
-class PoolStats {
-    /**
-     * 构造函数
-     *
-     * @param {Object} options - 配置选项
-     * @param {Object} options.logger - 日志记录器
-     */
-    constructor(options = {}) {
-        this._logger = options.logger || console;
-
-        this._stats = new Map(); // Map<poolName, StatsData>
-        this._buffer = [];       // 缓冲区（修复问题6）
-
-        // 启动批量更新（每100ms）
-        this._batchInterval = setInterval(() => {
-            this._flush();
-        }, 100);
-    }
-
-    /**
-     * 记录选择事件
-     *
-     * @param {string} poolName - 连接池名称
-     * @param {string} operation - 操作类型
-     */
-    recordSelection(poolName, operation) {
-        this._buffer.push({
-            poolName,
-            type: 'selection',
-            operation,
-            timestamp: Date.now()
-        });
-    }
-
-    /**
-     * 记录查询（测试兼容方法）
-     *
-     * @param {string} poolName - 连接池名称
-     * @param {number} responseTime - 响应时间（毫秒）
-     * @param {Error|null} error - 错误对象
-     */
-    async recordQuery(poolName, responseTime, error) {
-        this.recordRequest(poolName, responseTime, !error);
-        // 立即刷新以确保测试能获取最新统计
-        this._flush();
-    }
-
-    /**
-     * 记录连接数（测试兼容方法）
-     *
-     * @param {string} poolName - 连接池名称
-     * @param {number} count - 连接数
-     */
-    recordConnections(poolName, count) {
-        let stats = this._stats.get(poolName);
-        if (!stats) {
-            stats = {
-                connections: count,
-                available: 0,
-                waiting: 0,
-                totalRequests: 0,
-                successRequests: 0,
-                failedRequests: 0,
-                totalResponseTime: 0,
-                avgResponseTime: 0,
-                errorRate: 0
-            };
-            this._stats.set(poolName, stats);
-        } else {
-            stats.connections = count;
-        }
-    }
-
-    /**
-     * 记录请求完成
-     *
-     * @param {string} poolName - 连接池名称
-     * @param {number} responseTime - 响应时间（毫秒）
-     * @param {boolean} success - 是否成功
-     */
-    recordRequest(poolName, responseTime, success) {
-        this._buffer.push({
-            poolName,
-            type: 'request',
-            responseTime,
-            success,
-            timestamp: Date.now()
-        });
-    }
-
-    /**
-     * 批量更新统计（修复问题6）
-     *
-     * @private
-     */
-    _flush() {
-        if (this._buffer.length === 0) {
-            return;
-        }
-
-        // 取出缓冲区数据
-        const batch = this._buffer.splice(0);
-
-        // 批量更新
-        for (const item of batch) {
-            this._updateStats(item);
-        }
-    }
-
-    /**
-     * 更新统计
-     *
-     * @private
-     */
-    _updateStats(item) {
-        const { poolName } = item;
-
-        // 获取或创建统计对象
-        let stats = this._stats.get(poolName);
-        if (!stats) {
-            stats = {
-                connections: 0,
-                available: 0,
-                waiting: 0,
-                totalRequests: 0,
-                successRequests: 0,
-                failedRequests: 0,
-                totalResponseTime: 0,
-                avgResponseTime: 0,
-                errorRate: 0
-            };
-            this._stats.set(poolName, stats);
-        }
-
-        // 根据类型更新
-        if (item.type === 'selection') {
-            // 选择事件：暂时不需要更新
-        } else if (item.type === 'request') {
-            // 请求事件
-            stats.totalRequests++;
-
-            if (item.success) {
-                stats.successRequests++;
-            } else {
-                stats.failedRequests++;
-            }
-
-            stats.totalResponseTime += item.responseTime;
-            stats.avgResponseTime = stats.totalResponseTime / stats.totalRequests;
-            stats.errorRate = stats.failedRequests / stats.totalRequests;
-        }
-    }
-
-    /**
-     * 获取连接池统计
-     *
-     * @param {string} poolName - 连接池名称
-     * @returns {Object} 统计对象（总是返回，不存在则返回初始值）
-     */
-    getStats(poolName) {
-        let stats = this._stats.get(poolName);
-        if (!stats) {
-            // 返回初��统计对象
-            stats = {
-                connections: 0,
-                available: 0,
-                waiting: 0,
-                totalRequests: 0,
-                successRequests: 0,
-                failedRequests: 0,
-                totalResponseTime: 0,
-                avgResponseTime: 0,
-                errorRate: 0
-            };
-        }
-        return { ...stats }; // 返回副本
-    }
-
-    /**
-     * 获取所有统计
-     *
-     * @returns {Object}
-     */
-    getAllStats() {
-        const result = {};
-
-        for (const [poolName, stats] of this._stats.entries()) {
-            result[poolName] = { ...stats };
-        }
-
-        return result;
-    }
-
-    /**
-     * 重置统计
-     *
-     * @param {string} [poolName] - 连接池名称（不传则重置所有）
-     */
-    reset(poolName) {
-        if (poolName) {
-            this._stats.delete(poolName);
-        } else {
-            this._stats.clear();
-        }
-    }
-
-    /**
-     * 重置所有统计
-     */
-    resetAll() {
-        this._stats.clear();
-        this._buffer = [];
-    }
-
-    /**
-     * 关闭统计收集
-     */
-    close() {
-        if (this._batchInterval) {
-            clearInterval(this._batchInterval);
-            this._batchInterval = null;
-        }
-
-        // 刷新剩余缓冲
-        this._flush();
-    }
-}
-
-module.exports = PoolStats;
-
-

package/lib/infrastructure/ssh-tunnel-ssh2.js

@@ -1,212 +0,0 @@
-/**
- * SSH隧道管理器 - ssh2实现
- * 支持密码认证和私钥认证
- */
-
-const { Client } = require('ssh2');
-const net = require('net');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * 基于ssh2的SSH隧道管理器
- * 支持密码认证和私钥认证
- */
-class SSHTunnelSSH2 {
-    /**
-     * @param {Object} sshConfig - SSH配置
-     * @param {string} sshConfig.host - SSH服务器地址
-     * @param {number} [sshConfig.port=22] - SSH端口
-     * @param {string} sshConfig.username - SSH用户名
-     * @param {string} [sshConfig.password] - SSH密码
-     * @param {string} [sshConfig.privateKey] - 私钥内容
-     * @param {string} [sshConfig.privateKeyPath] - 私钥路径
-     * @param {string} [sshConfig.passphrase] - 私钥密码
-     * @param {number} [sshConfig.localPort] - 本地监听端口（可选，默认随机）
-     * @param {number} [sshConfig.readyTimeout=20000] - 连接超时（毫秒）
-     * @param {number} [sshConfig.keepaliveInterval=30000] - 心跳间隔（毫秒）
-     * @param {string} remoteHost - 远程主机（数据库服务器地址）
-     * @param {number} remotePort - 远程端口（数据库端口）
-     * @param {Object} options - 可选配置
-     * @param {Object} options.logger - 日志记录器
-     * @param {string} options.name - 隧道名称（用于日志）
-     */
-    constructor(sshConfig, remoteHost, remotePort, options = {}) {
-        this.sshConfig = sshConfig;
-        this.remoteHost = remoteHost;
-        this.remotePort = remotePort;
-        this.logger = options.logger;
-        this.name = options.name || `${remoteHost}:${remotePort}`;
-
-        this.sshClient = null;
-        this.server = null;
-        this.localPort = null;
-        this.isConnected = false;
-    }
-
-    /**
-     * 建立SSH隧道
-     * @returns {Promise<number>} 本地监听端口
-     */
-    async connect() {
-        if (this.isConnected) {
-            this.logger?.warn?.(`SSH tunnel [${this.name}] already connected`);
-            return this.localPort;
-        }
-
-        return new Promise((resolve, reject) => {
-            this.sshClient = new Client();
-
-            this.sshClient.on('ready', () => {
-                this.logger?.info?.(`✅ SSH connection established [${this.name}]`);
-
-                // 创建本地TCP服务器（端口转发）
-                this.server = net.createServer((sock) => {
-                    this.sshClient.forwardOut(
-                        sock.remoteAddress,
-                        sock.remotePort,
-                        this.remoteHost,
-                        this.remotePort,
-                        (err, stream) => {
-                            if (err) {
-                                this.logger?.error?.(`SSH forward error [${this.name}]`, err);
-                                return sock.end();
-                            }
-                            sock.pipe(stream).pipe(sock);
-                        }
-                    );
-                });
-
-                // 监听本地端口（0 = 随机端口）
-                const port = this.sshConfig.localPort || 0;
-                this.server.listen(port, 'localhost', () => {
-                    this.localPort = this.server.address().port;
-                    this.isConnected = true;
-
-                    this.logger?.info?.(`✅ SSH tunnel ready [${this.name}]`, {
-                        localPort: this.localPort,
-                        remote: `${this.remoteHost}:${this.remotePort}`
-                    });
-
-                    resolve(this.localPort);
-                });
-
-                this.server.on('error', (err) => {
-                    this.logger?.error?.(`Local server error [${this.name}]`, err);
-                    reject(err);
-                });
-            });
-
-            this.sshClient.on('error', (err) => {
-                this.logger?.error?.(`SSH connection error [${this.name}]`, err);
-                reject(err);
-            });
-
-            this.sshClient.on('end', () => {
-                this.logger?.info?.(`SSH connection ended [${this.name}]`);
-                this.isConnected = false;
-            });
-
-            // 构建认证配置并连接
-            try {
-                const authConfig = this._buildAuthConfig();
-                this.sshClient.connect(authConfig);
-            } catch (err) {
-                reject(err);
-            }
-        });
-    }
-
-    /**
-     * 关闭SSH隧道
-     */
-    async close() {
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
-
-        if (this.sshClient) {
-            this.sshClient.end();
-            this.sshClient = null;
-        }
-
-        this.isConnected = false;
-        this.localPort = null;
-
-        this.logger?.info?.(`✅ SSH tunnel closed [${this.name}]`);
-    }
-
-    /**
-     * 获取隧道连接URI
-     * @param {string} protocol - 数据库协议（mongodb/postgresql/mysql/redis）
-     * @param {string} originalUri - 原始URI
-     * @returns {string} 替换后的本地URI
-     */
-    getTunnelUri(protocol, originalUri) {
-        if (!this.isConnected) {
-            throw new Error(`SSH tunnel [${this.name}] not connected`);
-        }
-
-        // 替换主机:端口为 localhost:本地端口
-        const pattern = new RegExp(`${protocol}://([^@]*@)?([^:/]+):(\\d+)`);
-        const replacement = `${protocol}://$1localhost:${this.localPort}`;
-
-        return originalUri.replace(pattern, replacement);
-    }
-
-    /**
-     * 获取本地连接地址
-     * @returns {string} localhost:端口
-     */
-    getLocalAddress() {
-        if (!this.isConnected) {
-            throw new Error(`SSH tunnel [${this.name}] not connected`);
-        }
-        return `localhost:${this.localPort}`;
-    }
-
-    /**
-     * 构建SSH认证配置
-     * @private
-     */
-    _buildAuthConfig() {
-        const { host, port, username, password, privateKey, privateKeyPath, passphrase } = this.sshConfig;
-
-        if (!host || !username) {
-            throw new Error('SSH config requires: host, username');
-        }
-
-        const config = {
-            host,
-            port: port || 22,
-            username,
-            readyTimeout: this.sshConfig.readyTimeout || 20000,
-            keepaliveInterval: this.sshConfig.keepaliveInterval || 30000,
-        };
-
-        // 优先使用私钥认证
-        if (privateKey) {
-            config.privateKey = privateKey;
-            if (passphrase) config.passphrase = passphrase;
-        } else if (privateKeyPath) {
-            const resolvedPath = privateKeyPath.startsWith('~')
-                ? path.join(os.homedir(), privateKeyPath.slice(1))
-                : privateKeyPath;
-            config.privateKey = fs.readFileSync(resolvedPath);
-            if (passphrase) config.passphrase = passphrase;
-        } else if (password) {
-            // 密码认证
-            config.password = password;
-        } else {
-            throw new Error('SSH authentication required: privateKey, privateKeyPath, or password');
-        }
-
-        return config;
-    }
-}
-
-module.exports = { SSHTunnelSSH2 };
-
-

package/lib/infrastructure/ssh-tunnel.js

@@ -1,41 +0,0 @@
-/**
- * SSH隧道管理器 - 统一入口
- * 使用ssh2库实现，支持密码认证和私钥认证
- */
-
-const { SSHTunnelSSH2 } = require('./ssh-tunnel-ssh2');
-
-/**
- * SSH隧道管理器
- * 直接使用ssh2实现
- */
-class SSHTunnelManager {
-    /**
-     * 创建SSH隧道实例
-     * @param {Object} sshConfig - SSH配置
-     * @param {string} remoteHost - 远程主机
-     * @param {number} remotePort - 远程端口
-     * @param {Object} options - 可选配置
-     * @returns {Object} SSH隧道实例
-     */
-    static create(sshConfig, remoteHost, remotePort, options = {}) {
-        return new SSHTunnelSSH2(sshConfig, remoteHost, remotePort, options);
-    }
-
-    /**
-     * 获取当前实现信息
-     * @returns {Object}
-     */
-    static getInfo() {
-        return {
-            implementation: 'ssh2',
-            supportsPassword: true,
-            supportsPrivateKey: true,
-            dependencies: ['ssh2']
-        };
-    }
-}
-
-module.exports = { SSHTunnelManager };
-
-

package/lib/infrastructure/uri-parser.js

@@ -1,36 +0,0 @@
-/**
- * 通用URI解析器
- * 支持：mongodb://、postgresql://、mysql://、redis://
- */
-
-/**
- * 解析数据库连接URI
- * @param {string} uri - 数据库连接URI
- * @returns {{protocol: string, auth: string|null, host: string, port: number}} 解析结果
- */
-function parseUri(uri) {
-    const patterns = {
-        mongodb: /mongodb:\/\/([^@]*@)?([^:/]+):(\d+)/,
-        postgresql: /postgresql:\/\/([^@]*@)?([^:/]+):(\d+)/,
-        mysql: /mysql:\/\/([^@]*@)?([^:/]+):(\d+)/,
-        redis: /redis:\/\/([^@]*@)?([^:/]+):(\d+)/
-    };
-
-    for (const [protocol, pattern] of Object.entries(patterns)) {
-        const match = uri.match(pattern);
-        if (match) {
-            return {
-                protocol,
-                auth: match[1] ? match[1].slice(0, -1) : null,  // 去掉末尾的@
-                host: match[2],
-                port: parseInt(match[3], 10)
-            };
-        }
-    }
-
-    throw new Error(`Unsupported URI format: ${uri}`);
-}
-
-module.exports = { parseUri };
-
-

package/lib/lock/Lock.js

@@ -1,67 +0,0 @@
-/**
- * 业务锁对象
- * 表示一个已获取的锁，提供释放和续期方法
- */
-class Lock {
-    /**
-     * @param {string} key - 锁的标识
-     * @param {string} lockId - 锁的唯一ID
-     * @param {Object} manager - 锁管理器实例
-     * @param {number} ttl - 锁的过期时间（毫秒）
-     */
-    constructor(key, lockId, manager, ttl) {
-        this.key = key;
-        this.lockId = lockId;
-        this.manager = manager;
-        this.ttl = ttl;
-        this.released = false;
-        this.acquiredAt = Date.now();
-    }
-
-    /**
-     * 释放锁
-     * @returns {Promise<boolean>}
-     */
-    async release() {
-        if (this.released) {
-            return false;
-        }
-
-        const result = await this.manager.releaseLock(this.key, this.lockId);
-        this.released = true;
-        return result;
-    }
-
-    /**
-     * 续期（延长锁的过期时间）
-     * @param {number} [ttl] - 新的过期时间，默认使用原TTL
-     * @returns {Promise<boolean>}
-     */
-    async renew(ttl) {
-        if (this.released) {
-            return false;
-        }
-
-        return this.manager.renewLock(this.key, this.lockId, ttl || this.ttl);
-    }
-
-    /**
-     * 检查锁是否仍被持有
-     * @returns {boolean}
-     */
-    isHeld() {
-        return !this.released;
-    }
-
-    /**
-     * 获取锁持有时间
-     * @returns {number} 毫秒
-     */
-    getHoldTime() {
-        return Date.now() - this.acquiredAt;
-    }
-}
-
-module.exports = Lock;
-
-

package/lib/lock/errors.js

@@ -1,28 +0,0 @@
-/**
- * 锁获取失败错误
- */
-class LockAcquireError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'LockAcquireError';
-        this.code = 'LOCK_ACQUIRE_FAILED';
-    }
-}
-
-/**
- * 锁超时错误
- */
-class LockTimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'LockTimeoutError';
-        this.code = 'LOCK_TIMEOUT';
-    }
-}
-
-module.exports = {
-    LockAcquireError,
-    LockTimeoutError
-};
-
-

package/lib/lock/index.js

@@ -1,13 +0,0 @@
-/**
- * 业务锁模块导出
- */
-const Lock = require('./Lock');
-const { LockAcquireError, LockTimeoutError } = require('./errors');
-
-module.exports = {
-    Lock,
-    LockAcquireError,
-    LockTimeoutError
-};
-
-