@cmd233/mcp-database-server 1.1.1 → 1.1.3

package/dist/src/db/postgresql-adapter.js

@@ -1,13 +1,13 @@
 import pg from 'pg';
 /**
- * PostgreSQL database adapter implementation
+ * PostgreSQL 数据库适配器实现
  */
 export class PostgresqlAdapter {
     constructor(connectionInfo) {
         this.client = null;
         this.host = connectionInfo.host;
         this.database = connectionInfo.database;
-        // Create PostgreSQL connection config
+        // 创建 PostgreSQL 连接配置
         this.config = {
             host: connectionInfo.host,
             database: connectionInfo.database,
@@ -15,12 +15,12 @@ export class PostgresqlAdapter {
             user: connectionInfo.user,
             password: connectionInfo.password,
             ssl: connectionInfo.ssl,
-            // Add connection timeout if provided (in milliseconds)
+            // 如果提供了连接超时,则添加(以毫秒为单位)
             connectionTimeoutMillis: connectionInfo.connectionTimeout || 30000,
         };
     }
     /**
-     * Initialize PostgreSQL connection
+     * 初始化 PostgreSQL 连接
      */
     async init() {
         try {
@@ -43,17 +43,17 @@ export class PostgresqlAdapter {
         }
     }
     /**
-     * Execute a SQL query and get all results
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with query results
+     * 执行 SQL 查询并获取所有结果
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含查询结果的 Promise
      */
     async all(query, params = []) {
         if (!this.client) {
             throw new Error("Database not initialized");
         }
         try {
-            // PostgreSQL uses $1, $2, etc. for parameterized queries
+            // PostgreSQL 使用 $1, $2 等作为参数化查询的占位符
             const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
             const result = await this.client.query(preparedQuery, params);
             return result.rows;
@@ -63,23 +63,23 @@ export class PostgresqlAdapter {
         }
     }
     /**
-     * Execute a SQL query that modifies data
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with result info
+     * 执行修改数据的 SQL 查询
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含结果信息的 Promise
      */
     async run(query, params = []) {
         if (!this.client) {
             throw new Error("Database not initialized");
         }
         try {
-            // Replace ? with numbered parameters
+            // 将 ? 替换为编号参数
             const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
             let lastID = 0;
             let changes = 0;
-            // For INSERT queries, try to get the inserted ID
+            // 对于 INSERT 查询,尝试获取插入的 ID
             if (query.trim().toUpperCase().startsWith('INSERT')) {
-                // Add RETURNING clause to get the inserted ID if it doesn't already have one
+                // 如果查询中没有 RETURNING 子句,则添加以获取插入的 ID
                 const returningQuery = preparedQuery.includes('RETURNING')
                     ? preparedQuery
                     : `${preparedQuery} RETURNING id`;
@@ -98,9 +98,9 @@ export class PostgresqlAdapter {
         }
     }
     /**
-     * Execute multiple SQL statements
-     * @param query SQL statements to execute
-     * @returns Promise that resolves when execution completes
+     * 执行多条 SQL 语句
+     * @param query 要执行的 SQL 语句
+     * @returns 执行完成后解析的 Promise
      */
     async exec(query) {
         if (!this.client) {
@@ -114,7 +114,7 @@ export class PostgresqlAdapter {
         }
     }
     /**
-     * Close the database connection
+     * 关闭数据库连接
      */
     async close() {
         if (this.client) {
@@ -123,7 +123,7 @@ export class PostgresqlAdapter {
         }
     }
     /**
-     * Get database metadata
+     * 获取数据库元数据
      */
     getMetadata() {
         return {
@@ -134,14 +134,14 @@ export class PostgresqlAdapter {
         };
     }
     /**
-     * Get database-specific query for listing tables
+     * 获取用于列出表的数据库特定查询
      */
     getListTablesQuery() {
         return "SELECT table_name as name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name";
     }
     /**
-     * Get database-specific query for describing a table
-     * @param tableName Table name
+     * 获取用于描述表结构的数据库特定查询
+     * @param tableName 表名
      */
     getDescribeTableQuery(tableName) {
         return `

package/dist/src/db/sqlite-adapter.js

@@ -1,6 +1,6 @@
 import sqlite3 from "sqlite3";
 /**
- * SQLite database adapter implementation
+ * SQLite 数据库适配器实现
  */
 export class SqliteAdapter {
     constructor(dbPath) {
@@ -8,11 +8,11 @@ export class SqliteAdapter {
         this.dbPath = dbPath;
     }
     /**
-     * Initialize the SQLite database connection
+     * 初始化 SQLite 数据库连接
      */
     async init() {
         return new Promise((resolve, reject) => {
-            // Ensure the dbPath is accessible
+            // 确保数据库路径可访问
             console.error(`[INFO] Opening SQLite database at: ${this.dbPath}`);
             this.db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, (err) => {
                 if (err) {
@@ -27,10 +27,10 @@ export class SqliteAdapter {
         });
     }
     /**
-     * Execute a SQL query and get all results
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with query results
+     * 执行 SQL 查询并返回所有结果
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含查询结果的 Promise
      */
     async all(query, params = []) {
         if (!this.db) {
@@ -48,10 +48,10 @@ export class SqliteAdapter {
         });
     }
     /**
-     * Execute a SQL query that modifies data
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with result info
+     * 执行修改数据的 SQL 查询
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含结果信息的 Promise
      */
     async run(query, params = []) {
         if (!this.db) {
@@ -69,9 +69,9 @@ export class SqliteAdapter {
         });
     }
     /**
-     * Execute multiple SQL statements
-     * @param query SQL statements to execute
-     * @returns Promise that resolves when execution completes
+     * 执行多条 SQL 语句
+     * @param query 要执行的 SQL 语句
+     * @returns 执行完成后完成的 Promise
      */
     async exec(query) {
         if (!this.db) {
@@ -89,7 +89,7 @@ export class SqliteAdapter {
         });
     }
     /**
-     * Close the database connection
+     * 关闭数据库连接
      */
     async close() {
         return new Promise((resolve, reject) => {
@@ -109,7 +109,7 @@ export class SqliteAdapter {
         });
     }
     /**
-     * Get database metadata
+     * 获取数据库元数据
      */
     getMetadata() {
         return {
@@ -119,14 +119,14 @@ export class SqliteAdapter {
         };
     }
     /**
-     * Get database-specific query for listing tables
+     * 获取列出所有表的数据库特定查询
      */
     getListTablesQuery() {
         return "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'";
     }
     /**
-     * Get database-specific query for describing a table
-     * @param tableName Table name
+     * 获取描述表结构的数据库特定查询
+     * @param tableName 表名
      */
     getDescribeTableQuery(tableName) {
         return `PRAGMA table_info(${tableName})`;

package/dist/src/db/sqlserver-adapter.js

@@ -1,91 +1,211 @@
 import sql from 'mssql';
 /**
- * SQL Server database adapter implementation
+ * SQL Server 数据库适配器实现
  */
 export class SqlServerAdapter {
     constructor(connectionInfo) {
         this.pool = null;
+        this.isConnecting = false;
         this.server = connectionInfo.server;
         this.database = connectionInfo.database;
-        // Create SQL Server connection config
+        // 创建 SQL Server 连接配置
         this.config = {
             server: connectionInfo.server,
             database: connectionInfo.database,
             port: connectionInfo.port || 1433,
+            // 连接池配置
+            pool: {
+                max: 10, // 最大连接数
+                min: 1, // 最小连接数
+                idleTimeoutMillis: 30000, // 空闲连接超时时间 (30秒)
+            },
+            // 连接超时和请求超时配置
+            connectionTimeout: 30000, // 连接超时 (30秒)
+            requestTimeout: 30000, // 请求超时 (30秒)
             options: {
                 trustServerCertificate: connectionInfo.trustServerCertificate ?? true,
+                enableArithAbort: true,
                 ...connectionInfo.options
             }
         };
-        // Add authentication options
+        // 添加认证选项
         if (connectionInfo.user && connectionInfo.password) {
             this.config.user = connectionInfo.user;
             this.config.password = connectionInfo.password;
         }
         else {
-            // Use Windows authentication if no username/password provided
+            // 如果未提供用户名/密码,则使用 Windows 身份验证
             this.config.options.trustedConnection = true;
-            this.config.options.enableArithAbort = true;
         }
     }
     /**
-     * Initialize SQL Server connection
+     * 初始化 SQL Server 连接
      */
     async init() {
+        await this.ensureConnection();
+    }
+    /**
+     * 确保连接可用，如果连接断开则自动重连
+     */
+    async ensureConnection() {
+        // 如果正在连接中，等待连接完成
+        if (this.isConnecting) {
+            await this.waitForConnection();
+            if (this.pool && this.pool.connected) {
+                return this.pool;
+            }
+        }
+        // 检查现有连接是否可用
+        if (this.pool && this.pool.connected) {
+            return this.pool;
+        }
+        // 需要建立新连接
+        this.isConnecting = true;
         try {
+            // 如果存在旧的连接池，先关闭它
+            if (this.pool) {
+                try {
+                    await this.pool.close();
+                }
+                catch (closeErr) {
+                    console.error(`[WARN] Error closing old connection pool: ${closeErr.message}`);
+                }
+                this.pool = null;
+            }
             console.error(`[INFO] Connecting to SQL Server: ${this.server}, Database: ${this.database}`);
-            this.pool = await new sql.ConnectionPool(this.config).connect();
+            const pool = new sql.ConnectionPool(this.config);
+            // 使用单次监听器防止内存泄漏
+            pool.once('error', (err) => {
+                console.error(`[ERROR] SQL Server connection pool error: ${err.message}`);
+                // 标记连接池为不可用，下次查询时会自动重连
+                if (this.pool === pool) {
+                    this.pool = null;
+                }
+            });
+            this.pool = await pool.connect();
             console.error(`[INFO] SQL Server connection established successfully`);
+            return this.pool;
         }
         catch (err) {
+            this.pool = null;
             console.error(`[ERROR] SQL Server connection error: ${err.message}`);
             throw new Error(`Failed to connect to SQL Server: ${err.message}`);
         }
+        finally {
+            this.isConnecting = false;
+        }
     }
     /**
-     * Execute a SQL query and get all results
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with query results
+     * 等待正在进行的连接完成
      */
-    async all(query, params = []) {
-        if (!this.pool) {
-            throw new Error("Database not initialized");
+    async waitForConnection() {
+        const maxWait = 30000; // 最大等待30秒
+        const interval = 100; // 每100ms检查一次
+        let waited = 0;
+        while (this.isConnecting && waited < maxWait) {
+            await new Promise(resolve => setTimeout(resolve, interval));
+            waited += interval;
         }
-        try {
-            const request = this.pool.request();
-            // Add parameters to the request
+        // 如果超时，重置状态并抛出错误
+        if (this.isConnecting) {
+            this.isConnecting = false;
+            throw new Error('Connection timeout');
+        }
+    }
+    /**
+     * 执行带重试的操作
+     */
+    async executeWithRetry(operation, retries = 2) {
+        let lastError = null;
+        let poolAcquired = false; // 标记是否已成功获取连接池
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                const pool = await this.ensureConnection();
+                poolAcquired = true; // 成功获取连接池
+                return await operation(pool);
+            }
+            catch (err) {
+                lastError = err;
+                const errorMessage = lastError.message.toLowerCase();
+                // 检查是否是连接相关的错误
+                const isConnectionError = errorMessage.includes('connection') ||
+                    errorMessage.includes('socket') ||
+                    errorMessage.includes('timeout') ||
+                    errorMessage.includes('closed') ||
+                    errorMessage.includes('econnreset') ||
+                    errorMessage.includes('econnrefused') ||
+                    errorMessage.includes('network') ||
+                    errorMessage.includes('failed to connect');
+                // 只有在获取连接池后（即 poolAcquired = true）发生的连接错误才重试
+                // ensureConnection 本身的错误（如认证失败、连接超时）不应重试
+                if (isConnectionError && poolAcquired && attempt < retries && this.pool !== null) {
+                    console.error(`[WARN] Connection error detected, attempting reconnect (attempt ${attempt + 1}/${retries}): ${lastError.message}`);
+                    this.pool = null;
+                    poolAcquired = false; // 重置标记
+                    await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
+                    continue;
+                }
+                throw lastError;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * 关闭数据库连接
+     */
+    async close() {
+        // 等待正在进行的连接完成
+        if (this.isConnecting) {
+            await this.waitForConnection();
+        }
+        if (this.pool) {
+            try {
+                await this.pool.close();
+            }
+            catch (err) {
+                console.error(`[WARN] Error closing connection pool: ${err.message}`);
+            }
+            this.pool = null;
+        }
+        this.isConnecting = false;
+    }
+    /**
+     * 执行 SQL 查询并获取所有结果
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含查询结果的 Promise
+     */
+    async all(query, params = []) {
+        return this.executeWithRetry(async (pool) => {
+            const request = pool.request();
+            // 向请求添加参数
             params.forEach((param, index) => {
                 request.input(`param${index}`, param);
             });
-            // Replace ? with named parameters
-            const preparedQuery = query.replace(/\?/g, (_, i) => `@param${i}`);
+            // 将 ? 替换为命名参数
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `@param${paramIndex++}`);
             const result = await request.query(preparedQuery);
             return result.recordset;
-        }
-        catch (err) {
-            throw new Error(`SQL Server query error: ${err.message}`);
-        }
+        });
     }
     /**
-     * Execute a SQL query that modifies data
-     * @param query SQL query to execute
-     * @param params Query parameters
-     * @returns Promise with result info
+     * 执行修改数据的 SQL 查询
+     * @param query 要执行的 SQL 查询
+     * @param params 查询参数
+     * @returns 包含结果信息的 Promise
      */
     async run(query, params = []) {
-        if (!this.pool) {
-            throw new Error("Database not initialized");
-        }
-        try {
-            const request = this.pool.request();
-            // Add parameters to the request
+        return this.executeWithRetry(async (pool) => {
+            const request = pool.request();
+            // 向请求添加参数
             params.forEach((param, index) => {
                 request.input(`param${index}`, param);
             });
-            // Replace ? with named parameters
-            const preparedQuery = query.replace(/\?/g, (_, i) => `@param${i}`);
-            // Add output parameter for identity value if it's an INSERT
+            // 将 ? 替换为命名参数
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `@param${paramIndex++}`);
+            // 如果是 INSERT,添加标识值的输出参数
             let lastID = 0;
             if (query.trim().toUpperCase().startsWith('INSERT')) {
                 request.output('insertedId', sql.Int, 0);
@@ -94,46 +214,27 @@ export class SqlServerAdapter {
                 lastID = result.output.insertedId || 0;
             }
             else {
-                const result = await request.query(preparedQuery);
-                lastID = 0;
+                await request.query(preparedQuery);
             }
             return {
                 changes: this.getAffectedRows(query, lastID),
                 lastID: lastID
             };
-        }
-        catch (err) {
-            throw new Error(`SQL Server query error: ${err.message}`);
-        }
+        });
     }
     /**
-     * Execute multiple SQL statements
-     * @param query SQL statements to execute
-     * @returns Promise that resolves when execution completes
+     * 执行多条 SQL 语句
+     * @param query 要执行的 SQL 语句
+     * @returns 执行完成后解析的 Promise
      */
     async exec(query) {
-        if (!this.pool) {
-            throw new Error("Database not initialized");
-        }
-        try {
-            const request = this.pool.request();
+        return this.executeWithRetry(async (pool) => {
+            const request = pool.request();
             await request.batch(query);
-        }
-        catch (err) {
-            throw new Error(`SQL Server batch error: ${err.message}`);
-        }
-    }
-    /**
-     * Close the database connection
-     */
-    async close() {
-        if (this.pool) {
-            await this.pool.close();
-            this.pool = null;
-        }
+        });
     }
     /**
-     * Get database metadata
+     * 获取数据库元数据
      */
     getMetadata() {
         return {
@@ -144,43 +245,43 @@ export class SqlServerAdapter {
         };
     }
     /**
-     * Get database-specific query for listing tables
+     * 获取列出表的数据库特定查询
      */
     getListTablesQuery() {
         return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME";
     }
     /**
-     * Get database-specific query for describing a table
-     * @param tableName Table name
+     * 获取描述表的数据库特定查询
+     * @param tableName 表名
      */
     getDescribeTableQuery(tableName) {
-        return `
-      SELECT 
-        c.COLUMN_NAME as name,
-        c.DATA_TYPE as type,
-        CASE WHEN c.IS_NULLABLE = 'NO' THEN 1 ELSE 0 END as notnull,
-        CASE WHEN pk.CONSTRAINT_TYPE = 'PRIMARY KEY' THEN 1 ELSE 0 END as pk,
-        c.COLUMN_DEFAULT as dflt_value
-      FROM 
-        INFORMATION_SCHEMA.COLUMNS c
-      LEFT JOIN 
-        INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu ON c.TABLE_NAME = kcu.TABLE_NAME AND c.COLUMN_NAME = kcu.COLUMN_NAME
-      LEFT JOIN 
-        INFORMATION_SCHEMA.TABLE_CONSTRAINTS pk ON kcu.CONSTRAINT_NAME = pk.CONSTRAINT_NAME AND pk.CONSTRAINT_TYPE = 'PRIMARY KEY'
-      WHERE 
-        c.TABLE_NAME = '${tableName}'
-      ORDER BY 
-        c.ORDINAL_POSITION
+        return `
+      SELECT 
+        c.COLUMN_NAME as name,
+        c.DATA_TYPE as type,
+        CASE WHEN c.IS_NULLABLE = 'NO' THEN 1 ELSE 0 END as notnull,
+        CASE WHEN pk.CONSTRAINT_TYPE = 'PRIMARY KEY' THEN 1 ELSE 0 END as pk,
+        c.COLUMN_DEFAULT as dflt_value
+      FROM 
+        INFORMATION_SCHEMA.COLUMNS c
+      LEFT JOIN 
+        INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu ON c.TABLE_NAME = kcu.TABLE_NAME AND c.COLUMN_NAME = kcu.COLUMN_NAME
+      LEFT JOIN 
+        INFORMATION_SCHEMA.TABLE_CONSTRAINTS pk ON kcu.CONSTRAINT_NAME = pk.CONSTRAINT_NAME AND pk.CONSTRAINT_TYPE = 'PRIMARY KEY'
+      WHERE 
+        c.TABLE_NAME = '${tableName}'
+      ORDER BY 
+        c.ORDINAL_POSITION
     `;
     }
     /**
-     * Helper to get the number of affected rows based on query type
+     * 根据查询类型获取受影响行数的辅助方法
      */
     getAffectedRows(query, lastID) {
         const queryType = query.trim().split(' ')[0].toUpperCase();
         if (queryType === 'INSERT' && lastID > 0) {
             return 1;
         }
-        return 0; // For SELECT, unknown for UPDATE/DELETE without additional query
+        return 0; // 对于 SELECT 返回 0,对于 UPDATE/DELETE 在没有额外查询的情况下未知
     }
 }

package/dist/src/handlers/resourceHandlers.js

@@ -1,14 +1,14 @@
 import { dbAll, getListTablesQuery, getDescribeTableQuery, getDatabaseMetadata } from '../db/index.js';
 /**
- * Handle listing resources request
- * @returns List of available resources
+ * 处理列出资源的请求
+ * @returns 可用资源列表
  */
 export async function handleListResources() {
     try {
         const dbInfo = getDatabaseMetadata();
         const dbType = dbInfo.type;
         let resourceBaseUrl;
-        // Create appropriate URL based on database type
+        // 根据数据库类型创建适当的 URL
         if (dbType === 'sqlite' && dbInfo.path) {
             resourceBaseUrl = new URL(`sqlite:///${dbInfo.path}`);
         }
@@ -19,7 +19,7 @@ export async function handleListResources() {
             resourceBaseUrl = new URL(`db:///database`);
         }
         const SCHEMA_PATH = "schema";
-        // Use adapter-specific query to list tables
+        // 使用适配器特定的查询来列出表
         const query = getListTablesQuery();
         const result = await dbAll(query);
         return {
@@ -35,9 +35,9 @@ export async function handleListResources() {
     }
 }
 /**
- * Handle reading a specific resource
- * @param uri URI of the resource to read
- * @returns Resource contents
+ * 处理读取特定资源的请求
+ * @param uri 要读取的资源 URI
+ * @returns 资源内容
  */
 export async function handleReadResource(uri) {
     try {
@@ -49,7 +49,7 @@ export async function handleReadResource(uri) {
         if (schema !== SCHEMA_PATH) {
             throw new Error("Invalid resource URI");
         }
-        // Use adapter-specific query to describe the table
+        // 使用适配器特定的查询来描述表结构
         const query = getDescribeTableQuery(tableName);
         const result = await dbAll(query);
         return {

package/dist/src/handlers/toolHandlers.js

@@ -1,11 +1,11 @@
 import { formatErrorResponse } from '../utils/formatUtils.js';
-// Import all tool implementations
+// 导入所有工具实现
 import { readQuery, writeQuery, exportQuery } from '../tools/queryTools.js';
 import { createTable, alterTable, dropTable, listTables, describeTable } from '../tools/schemaTools.js';
 import { appendInsight, listInsights } from '../tools/insightTools.js';
 /**
- * Handle listing available tools
- * @returns List of available tools
+ * 处理列出可用工具的请求
+ * @returns 可用工具列表
  */
 export function handleListTools() {
     return {
@@ -120,10 +120,10 @@ export function handleListTools() {
     };
 }
 /**
- * Handle tool call requests
- * @param name Name of the tool to call
- * @param args Arguments for the tool
- * @returns Tool execution result
+ * 处理工具调用请求
+ * @param name 要调用的工具名称
+ * @param args 工具参数
+ * @returns 工具执行结果
  */
 export async function handleToolCall(name, args) {
     try {