monsqlize 1.3.1 → 2.0.1

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

@@ -1,211 +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,40 +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,35 +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,66 +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,27 +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,12 +0,0 @@
-/**
- * 业务锁模块导出
- */
-const Lock = require('./Lock');
-const { LockAcquireError, LockTimeoutError } = require('./errors');
-
-module.exports = {
-    Lock,
-    LockAcquireError,
-    LockTimeoutError
-};
-

package/lib/logger.js

@@ -1,224 +0,0 @@
-/**
- * 默认日志记录器工具类
- * 提供标准的日志记录功能，支持不同级别的日志输出
- *
- * v2.0 新增功能：
- * - traceId 支持（用于分布式追踪）
- * - 结构化日志输出（JSON 格式）
- * - 上下文信息（数据库、集合、操作等）
- */
-
-const crypto = require('crypto');
-
-/**
- * 生成唯一的 traceId
- * @returns {string} 16 字符的唯一 ID
- */
-function generateTraceId() {
-    return crypto.randomBytes(8).toString('hex');
-}
-
-/**
- * 异步本地存储（用于在异步调用链中传递 traceId）
- */
-let AsyncLocalStorage;
-try {
-    AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
-} catch (e) {
-    // Node.js < 12.17.0 不支持 AsyncLocalStorage
-    AsyncLocalStorage = null;
-}
-
-const traceStorage = AsyncLocalStorage ? new AsyncLocalStorage() : null;
-
-module.exports = class Logger {
-
-    /**
-     * 创建日志记录器实例
-     * @param {Object} [customLogger] - 自定义日志记录器
-     * @param {Function} customLogger.debug - debug级别日志方法
-     * @param {Function} customLogger.info - info级别日志方法
-     * @param {Function} customLogger.warn - warn级别日志方法
-     * @param {Function} customLogger.error - error级别日志方法
-     * @param {Object} [options] - 日志选项
-     * @param {boolean} [options.structured=false] - 是否使用结构化日志（JSON）
-     * @param {boolean} [options.enableTraceId=false] - 是否启用 traceId
-     * @returns {Object} 日志记录器对象
-     */
-    static create(customLogger, options = {}) {
-        if (customLogger && this.isValidLogger(customLogger)) {
-            // 如果提供自定义 logger，包装它以支持新特性
-            return this.wrapLogger(customLogger, options);
-        }
-
-        return this.createDefaultLogger(options);
-    }
-
-    /**
-     * 验证自定义日志记录器是否有效
-     * @param {Object} logger - 待验证的日志记录器
-     * @returns {boolean} 是否为有效的日志记录器
-     */
-    static isValidLogger(logger) {
-        const requiredMethods = ['debug', 'info', 'warn', 'error'];
-        return requiredMethods.every(method =>
-            typeof logger[method] === 'function'
-        );
-    }
-
-    /**
-     * 包装自定义 logger 以支持新特性
-     * @param {Object} baseLogger - 基础 logger
-     * @param {Object} options - 选项
-     * @returns {Object} 包装后的 logger
-     */
-    static wrapLogger(baseLogger, options = {}) {
-        const { structured = false, enableTraceId = false } = options;
-
-        const wrap = (level) => (msg, ...args) => {
-            const logData = this._prepareLogData(level, msg, args, { structured, enableTraceId });
-
-            if (structured) {
-                baseLogger[level](JSON.stringify(logData));
-            } else {
-                const prefix = enableTraceId && logData.traceId ? `[${logData.traceId}] ` : '';
-                baseLogger[level](`${prefix}${msg}`, ...args);
-            }
-        };
-
-        return {
-            debug: wrap('debug'),
-            info: wrap('info'),
-            warn: wrap('warn'),
-            error: wrap('error'),
-            // 暴露 traceId 管理方法
-            withTraceId: enableTraceId ? this.withTraceId : undefined,
-            getTraceId: enableTraceId ? this.getTraceId : undefined,
-        };
-    }
-
-    /**
-     * 准备日志数据
-     * @private
-     */
-    static _prepareLogData(level, msg, args, options) {
-        const logData = {
-            timestamp: new Date().toISOString(),
-            level: level.toUpperCase(),
-            message: msg,
-        };
-
-        // 添加 traceId
-        if (options.enableTraceId) {
-            const traceId = this.getTraceId();
-            if (traceId) logData.traceId = traceId;
-        }
-
-        // 处理额外参数（上下文信息）
-        if (args.length > 0) {
-            const context = args[0];
-            if (context && typeof context === 'object') {
-                logData.context = context;
-            }
-        }
-
-        return logData;
-    }
-
-    /**
-     * 创建默认的控制台日志记录器
-     * @param {Object} [options] - 日志选项
-     * @returns {Object} 默认日志记录器对象
-     */
-    static createDefaultLogger(options = {}) {
-        const { structured = false, enableTraceId = false } = options;
-
-        const createLogFn = (level, consoleFn) => {
-            return (msg, ...args) => {
-                const logData = this._prepareLogData(level, msg, args, { structured, enableTraceId });
-
-                if (structured) {
-                    consoleFn(JSON.stringify(logData));
-                } else {
-                    const prefix = enableTraceId && logData.traceId ? `[${logData.traceId}] ` : '';
-                    consoleFn(`[${level.toUpperCase()}] ${prefix}${msg}`, ...args);
-                }
-            };
-        };
-
-        return {
-            debug: createLogFn('debug', console.debug),
-            info: createLogFn('info', console.log),
-            warn: createLogFn('warn', console.warn),
-            error: createLogFn('error', console.error),
-            // 暴露 traceId 管理方法
-            withTraceId: enableTraceId ? this.withTraceId.bind(this) : undefined,
-            getTraceId: enableTraceId ? this.getTraceId.bind(this) : undefined,
-        };
-    }
-
-    /**
-     * 创建带时间戳的日志记录器
-     * @param {Object} [customLogger] - 自定义日志记录器
-     * @returns {Object} 带时间戳的日志记录器
-     */
-    static createWithTimestamp(customLogger) {
-        const baseLogger = this.create(customLogger);
-        const getTimestamp = () => new Date().toISOString();
-
-        return {
-            debug: (msg, ...args) => baseLogger.debug(`${getTimestamp()} ${msg}`, ...args),
-            info: (msg, ...args) => baseLogger.info(`${getTimestamp()} ${msg}`, ...args),
-            warn: (msg, ...args) => baseLogger.warn(`${getTimestamp()} ${msg}`, ...args),
-            error: (msg, ...args) => baseLogger.error(`${getTimestamp()} ${msg}`, ...args)
-        };
-    }
-
-    /**
-     * 创建静默日志记录器（不输出任何内容）
-     * @returns {Object} 静默日志记录器
-     */
-    static createSilent() {
-        const noop = () => {};
-        return {
-            debug: noop,
-            info: noop,
-            warn: noop,
-            error: noop
-        };
-    }
-
-    /**
-     * 在指定的 traceId 上下文中运行函数
-     * @param {Function} fn - 要执行的函数
-     * @param {string} [traceId] - 可选的 traceId，不提供则自动生成
-     * @returns {*} 函数执行结果
-     */
-    static withTraceId(fn, traceId = null) {
-        if (!traceStorage) {
-            // 不支持 AsyncLocalStorage，直接执行
-            return fn();
-        }
-
-        const id = traceId || generateTraceId();
-        return traceStorage.run(id, fn);
-    }
-
-    /**
-     * 获取当前上下文的 traceId
-     * @returns {string|null} traceId 或 null
-     */
-    static getTraceId() {
-        if (!traceStorage) return null;
-        return traceStorage.getStore() || null;
-    }
-
-    /**
-     * 生成新的 traceId
-     * @returns {string} 新的 traceId
-     */
-    static generateTraceId() {
-        return generateTraceId();
-    }
-};
-