@cmd233/mcp-database-server 1.1.6 → 1.2.0

package/dist/src/db/adapter.js

@@ -24,6 +24,6 @@ export function createDbAdapter(type, connectionInfo) {
         case 'mysql':
             return new MysqlAdapter(connectionInfo);
         default:
-            throw new Error(`Unsupported database type: ${type}`);
+            throw new Error(`不支持的数据库类型: ${type}`);
     }
 }

package/dist/src/db/index.js

@@ -18,7 +18,7 @@ export async function initDatabase(connectionInfo, dbType = 'sqlite') {
         await dbAdapter.init();
     }
     catch (error) {
-        throw new Error(`Failed to initialize database: ${error.message}`);
+        throw new Error(`数据库初始化失败: ${error.message}`);
     }
 }
 /**
@@ -29,7 +29,7 @@ export async function initDatabase(connectionInfo, dbType = 'sqlite') {
  */
 export function dbAll(query, params = []) {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.all(query, params);
 }
@@ -41,7 +41,7 @@ export function dbAll(query, params = []) {
  */
 export function dbRun(query, params = []) {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.run(query, params);
 }
@@ -52,7 +52,7 @@ export function dbRun(query, params = []) {
  */
 export function dbExec(query) {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.exec(query);
 }
@@ -70,7 +70,7 @@ export function closeDatabase() {
  */
 export function getDatabaseMetadata() {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.getMetadata();
 }
@@ -79,7 +79,7 @@ export function getDatabaseMetadata() {
  */
 export function getListTablesQuery() {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.getListTablesQuery();
 }
@@ -89,7 +89,44 @@ export function getListTablesQuery() {
  */
 export function getDescribeTableQuery(tableName) {
     if (!dbAdapter) {
-        throw new Error("Database not initialized");
+        throw new Error("数据库未初始化");
     }
     return dbAdapter.getDescribeTableQuery(tableName);
 }
+/**
+ * 获取列出视图的数据库特定查询
+ * 仅 SQL Server 支持，其他数据库返回空结果
+ */
+export function getListViewsQuery() {
+    if (!dbAdapter) {
+        throw new Error("数据库未初始化");
+    }
+    if (dbAdapter.getListViewsQuery) {
+        return dbAdapter.getListViewsQuery();
+    }
+    // 不支持视图的数据库返回空结果查询
+    return "SELECT 1 as name WHERE 1=0";
+}
+/**
+ * 获取视图定义的数据库特定查询
+ * 仅 SQL Server 支持
+ * @param viewName 视图名
+ */
+export function getViewDefinitionQuery(viewName) {
+    if (!dbAdapter) {
+        throw new Error("数据库未初始化");
+    }
+    if (dbAdapter.getViewDefinitionQuery) {
+        return dbAdapter.getViewDefinitionQuery(viewName);
+    }
+    throw new Error("当前数据库不支持视图功能");
+}
+/**
+ * 检查数据库是否支持视图功能
+ */
+export function supportsViews() {
+    if (!dbAdapter) {
+        return false;
+    }
+    return dbAdapter.supportsViews ? dbAdapter.supportsViews() : false;
+}

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

@@ -37,7 +37,7 @@ export class MysqlAdapter {
         if (connectionInfo.port && typeof connectionInfo.port !== 'number') {
             const parsedPort = parseInt(connectionInfo.port, 10);
             if (isNaN(parsedPort)) {
-                throw new Error(`Invalid port value for MySQL: ${connectionInfo.port}`);
+                throw new Error(`无效的 MySQL 端口号: ${connectionInfo.port}`);
             }
             this.config.port = parsedPort;
         }
@@ -49,13 +49,13 @@ export class MysqlAdapter {
      */
     async generateAwsAuthToken() {
         if (!this.awsRegion) {
-            throw new Error("AWS region is required for IAM authentication");
+            throw new Error("AWS IAM 认证需要 AWS 区域参数");
         }
         if (!this.config.user) {
-            throw new Error("AWS username is required for IAM authentication");
+            throw new Error("AWS IAM 认证需要 AWS 用户名参数");
         }
         try {
-            console.info(`[INFO] Generating AWS auth token for region: ${this.awsRegion}, host: ${this.host}, user: ${this.config.user}`);
+            console.info(`[INFO] 正在为区域 ${this.awsRegion} 生成 AWS 认证令牌, 主机: ${this.host}, 用户: ${this.config.user}`);
             const signer = new Signer({
                 region: this.awsRegion,
                 hostname: this.host,
@@ -63,12 +63,12 @@ export class MysqlAdapter {
                 username: this.config.user,
             });
             const token = await signer.getAuthToken();
-            console.info(`[INFO] AWS auth token generated successfully`);
+            console.info(`[INFO] AWS 认证令牌生成成功`);
             return token;
         }
         catch (err) {
-            console.error(`[ERROR] Failed to generate AWS auth token: ${err.message}`);
-            throw new Error(`AWS IAM authentication failed: ${err.message}. Please check your AWS credentials and IAM permissions.`);
+            console.error(`[ERROR] 生成 AWS 认证令牌失败: ${err.message}`);
+            throw new Error(`AWS IAM 认证失败: ${err.message}。请检查您的 AWS 凭据和 IAM 权限。`);
         }
     }
     /**
@@ -76,10 +76,10 @@ export class MysqlAdapter {
      */
     async init() {
         try {
-            console.info(`[INFO] Connecting to MySQL: ${this.host}, Database: ${this.database}`);
+            console.info(`[INFO] 正在连接 MySQL: ${this.host}, 数据库: ${this.database}`);
             // 处理 AWS IAM 认证
             if (this.awsIamAuth) {
-                console.info(`[INFO] Using AWS IAM authentication for user: ${this.config.user}`);
+                console.info(`[INFO] 正在为用户 ${this.config.user} 使用 AWS IAM 认证`);
                 try {
                     const authToken = await this.generateAwsAuthToken();
                     // 使用生成的令牌作为密码创建新配置
@@ -90,22 +90,22 @@ export class MysqlAdapter {
                     this.connection = await mysql.createConnection(awsConfig);
                 }
                 catch (err) {
-                    console.error(`[ERROR] AWS IAM authentication failed: ${err.message}`);
-                    throw new Error(`AWS IAM authentication failed: ${err.message}`);
+                    console.error(`[ERROR] AWS IAM 认证失败: ${err.message}`);
+                    throw new Error(`AWS IAM 认证失败: ${err.message}`);
                 }
             }
             else {
                 this.connection = await mysql.createConnection(this.config);
             }
-            console.info(`[INFO] MySQL connection established successfully`);
+            console.info(`[INFO] MySQL 连接成功建立`);
         }
         catch (err) {
-            console.error(`[ERROR] MySQL connection error: ${err.message}`);
+            console.error(`[ERROR] MySQL 连接错误: ${err.message}`);
             if (this.awsIamAuth) {
-                throw new Error(`Failed to connect to MySQL with AWS IAM authentication: ${err.message}. Please verify your AWS credentials, IAM permissions, and RDS configuration.`);
+                throw new Error(`使用 AWS IAM 认证连接 MySQL 失败: ${err.message}。请验证您的 AWS 凭据、IAM 权限和 RDS 配置。`);
             }
             else {
-                throw new Error(`Failed to connect to MySQL: ${err.message}`);
+                throw new Error(`连接 MySQL 失败: ${err.message}`);
             }
         }
     }
@@ -114,14 +114,14 @@ export class MysqlAdapter {
      */
     async all(query, params = []) {
         if (!this.connection) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             const [rows] = await this.connection.execute(query, params);
             return Array.isArray(rows) ? rows : [];
         }
         catch (err) {
-            throw new Error(`MySQL query error: ${err.message}`);
+            throw new Error(`MySQL 查询错误: ${err.message}`);
         }
     }
     /**
@@ -129,7 +129,7 @@ export class MysqlAdapter {
      */
     async run(query, params = []) {
         if (!this.connection) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             const [result] = await this.connection.execute(query, params);
@@ -138,7 +138,7 @@ export class MysqlAdapter {
             return { changes, lastID };
         }
         catch (err) {
-            throw new Error(`MySQL query error: ${err.message}`);
+            throw new Error(`MySQL 查询错误: ${err.message}`);
         }
     }
     /**
@@ -146,13 +146,13 @@ export class MysqlAdapter {
      */
     async exec(query) {
         if (!this.connection) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             await this.connection.query(query);
         }
         catch (err) {
-            throw new Error(`MySQL batch error: ${err.message}`);
+            throw new Error(`MySQL 批处理错误: ${err.message}`);
         }
     }
     /**

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

@@ -24,7 +24,7 @@ export class PostgresqlAdapter {
      */
     async init() {
         try {
-            console.error(`[INFO] Connecting to PostgreSQL: ${this.host}, Database: ${this.database}`);
+            console.error(`[INFO] 正在连接 PostgreSQL: ${this.host}, 数据库: ${this.database}`);
             console.error(`[DEBUG] Connection details:`, {
                 host: this.host,
                 database: this.database,
@@ -35,11 +35,11 @@ export class PostgresqlAdapter {
             });
             this.client = new pg.Client(this.config);
             await this.client.connect();
-            console.error(`[INFO] PostgreSQL connection established successfully`);
+            console.error(`[INFO] PostgreSQL 连接成功建立`);
         }
         catch (err) {
-            console.error(`[ERROR] PostgreSQL connection error: ${err.message}`);
-            throw new Error(`Failed to connect to PostgreSQL: ${err.message}`);
+            console.error(`[ERROR] PostgreSQL 连接错误: ${err.message}`);
+            throw new Error(`连接 PostgreSQL 失败: ${err.message}`);
         }
     }
     /**
@@ -50,16 +50,17 @@ export class PostgresqlAdapter {
      */
     async all(query, params = []) {
         if (!this.client) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             // PostgreSQL 使用 $1, $2 等作为参数化查询的占位符
-            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
             const result = await this.client.query(preparedQuery, params);
             return result.rows;
         }
         catch (err) {
-            throw new Error(`PostgreSQL query error: ${err.message}`);
+            throw new Error(`PostgreSQL 查询错误: ${err.message}`);
         }
     }
     /**
@@ -70,11 +71,12 @@ export class PostgresqlAdapter {
      */
     async run(query, params = []) {
         if (!this.client) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             // 将 ? 替换为编号参数
-            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
             let lastID = 0;
             let changes = 0;
             // 对于 INSERT 查询,尝试获取插入的 ID
@@ -94,7 +96,7 @@ export class PostgresqlAdapter {
             return { changes, lastID };
         }
         catch (err) {
-            throw new Error(`PostgreSQL query error: ${err.message}`);
+            throw new Error(`PostgreSQL 查询错误: ${err.message}`);
         }
     }
     /**
@@ -104,13 +106,13 @@ export class PostgresqlAdapter {
      */
     async exec(query) {
         if (!this.client) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         try {
             await this.client.query(query);
         }
         catch (err) {
-            throw new Error(`PostgreSQL batch error: ${err.message}`);
+            throw new Error(`PostgreSQL 批处理错误: ${err.message}`);
         }
     }
     /**

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

@@ -13,14 +13,14 @@ export class SqliteAdapter {
     async init() {
         return new Promise((resolve, reject) => {
             // 确保数据库路径可访问
-            console.error(`[INFO] Opening SQLite database at: ${this.dbPath}`);
+            console.error(`[INFO] 正在打开 SQLite 数据库: ${this.dbPath}`);
             this.db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, (err) => {
                 if (err) {
-                    console.error(`[ERROR] SQLite connection error: ${err.message}`);
+                    console.error(`[ERROR] SQLite 连接错误: ${err.message}`);
                     reject(err);
                 }
                 else {
-                    console.error("[INFO] SQLite database opened successfully");
+                    console.error("[INFO] SQLite 数据库成功打开");
                     resolve();
                 }
             });
@@ -34,7 +34,7 @@ export class SqliteAdapter {
      */
     async all(query, params = []) {
         if (!this.db) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         return new Promise((resolve, reject) => {
             this.db.all(query, params, (err, rows) => {
@@ -55,7 +55,7 @@ export class SqliteAdapter {
      */
     async run(query, params = []) {
         if (!this.db) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         return new Promise((resolve, reject) => {
             this.db.run(query, params, function (err) {
@@ -75,7 +75,7 @@ export class SqliteAdapter {
      */
     async exec(query) {
         if (!this.db) {
-            throw new Error("Database not initialized");
+            throw new Error("数据库未初始化");
         }
         return new Promise((resolve, reject) => {
             this.db.exec(query, (err) => {

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

@@ -68,28 +68,28 @@ export class SqlServerAdapter {
                     await this.pool.close();
                 }
                 catch (closeErr) {
-                    console.error(`[WARN] Error closing old connection pool: ${closeErr.message}`);
+                    console.error(`[WARN] 关闭旧连接池时出错: ${closeErr.message}`);
                 }
                 this.pool = null;
             }
-            console.error(`[INFO] Connecting to SQL Server: ${this.server}, Database: ${this.database}`);
+            console.error(`[INFO] 正在连接 SQL Server: ${this.server}, 数据库: ${this.database}`);
             const pool = new sql.ConnectionPool(this.config);
             // 使用单次监听器防止内存泄漏
             pool.once('error', (err) => {
-                console.error(`[ERROR] SQL Server connection pool error: ${err.message}`);
+                console.error(`[ERROR] SQL Server 连接池错误: ${err.message}`);
                 // 标记连接池为不可用，下次查询时会自动重连
                 if (this.pool === pool) {
                     this.pool = null;
                 }
             });
             this.pool = await pool.connect();
-            console.error(`[INFO] SQL Server connection established successfully`);
+            console.error(`[INFO] SQL Server 连接成功建立`);
             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}`);
+            console.error(`[ERROR] SQL Server 连接错误: ${err.message}`);
+            throw new Error(`连接 SQL Server 失败: ${err.message}`);
         }
         finally {
             this.isConnecting = false;
@@ -109,7 +109,7 @@ export class SqlServerAdapter {
         // 如果超时，重置状态并抛出错误
         if (this.isConnecting) {
             this.isConnecting = false;
-            throw new Error('Connection timeout');
+            throw new Error('连接超时');
         }
     }
     /**
@@ -139,7 +139,7 @@ export class SqlServerAdapter {
                 // 只有在获取连接池后（即 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}`);
+                    console.error(`[WARN] 检测到连接错误，正在尝试重新连接 (尝试 ${attempt + 1}/${retries}): ${lastError.message}`);
                     this.pool = null;
                     poolAcquired = false; // 重置标记
                     await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
@@ -163,7 +163,7 @@ export class SqlServerAdapter {
                 await this.pool.close();
             }
             catch (err) {
-                console.error(`[WARN] Error closing connection pool: ${err.message}`);
+                console.error(`[WARN] 关闭连接池时出错: ${err.message}`);
             }
             this.pool = null;
         }
@@ -207,17 +207,22 @@ export class SqlServerAdapter {
             const preparedQuery = query.replace(/\?/g, () => `@param${paramIndex++}`);
             // 如果是 INSERT,添加标识值的输出参数
             let lastID = 0;
+            let changes = 0;
             if (query.trim().toUpperCase().startsWith('INSERT')) {
                 request.output('insertedId', sql.Int, 0);
                 const updatedQuery = `${preparedQuery}; SELECT @insertedId = SCOPE_IDENTITY();`;
                 const result = await request.query(updatedQuery);
                 lastID = result.output.insertedId || 0;
+                // 使用 rowsAffected 获取受影响行数
+                changes = result.rowsAffected?.[0] || (lastID > 0 ? 1 : 0);
             }
             else {
-                await request.query(preparedQuery);
+                const result = await request.query(preparedQuery);
+                // 使用 rowsAffected 获取受影响行数
+                changes = result.rowsAffected?.[0] || 0;
             }
             return {
-                changes: this.getAffectedRows(query, lastID),
+                changes: changes,
                 lastID: lastID
             };
         });
@@ -251,8 +256,8 @@ export class SqlServerAdapter {
         return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME";
     }
     /**
-     * 获取描述表的数据库特定查询
-     * @param tableName 表名
+     * 获取描述表或视图的数据库特定查询
+     * @param tableName 表名或视图名
      */
     getDescribeTableQuery(tableName) {
         return `
@@ -272,10 +277,11 @@ export class SqlServerAdapter {
       LEFT JOIN
         sys.extended_properties ep
           ON ep.major_id = (
-            SELECT t.object_id
-            FROM sys.tables t
-            INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
-            WHERE t.name = '${tableName}' AND s.name = c.TABLE_SCHEMA
+            SELECT o.object_id
+            FROM sys.objects o
+            INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+            WHERE o.name = '${tableName}' AND s.name = c.TABLE_SCHEMA
+            AND o.type IN ('U', 'V')
           )
           AND ep.minor_id = c.ORDINAL_POSITION
           AND ep.name = 'MS_Description'
@@ -286,13 +292,23 @@ export class SqlServerAdapter {
     `;
     }
     /**
-     * 根据查询类型获取受影响行数的辅助方法
+     * 获取列出视图的数据库特定查询
      */
-    getAffectedRows(query, lastID) {
-        const queryType = query.trim().split(' ')[0].toUpperCase();
-        if (queryType === 'INSERT' && lastID > 0) {
-            return 1;
-        }
-        return 0; // 对于 SELECT 返回 0,对于 UPDATE/DELETE 在没有额外查询的情况下未知
+    getListViewsQuery() {
+        return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.VIEWS ORDER BY TABLE_NAME";
+    }
+    /**
+     * 获取视图定义的数据库特定查询
+     * @param viewName 视图名
+     * 注意: 使用 WITH ENCRYPTION 创建的视图无法获取定义
+     */
+    getViewDefinitionQuery(viewName) {
+        return `SELECT VIEW_DEFINITION as definition FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '${viewName}'`;
+    }
+    /**
+     * 检查数据库是否支持视图功能
+     */
+    supportsViews() {
+        return true;
     }
 }

package/dist/src/handlers/resourceHandlers.js

@@ -31,7 +31,7 @@ export async function handleListResources() {
         };
     }
     catch (error) {
-        throw new Error(`Error listing resources: ${error.message}`);
+        throw new Error(`列出资源失败: ${error.message}`);
     }
 }
 /**
@@ -47,7 +47,7 @@ export async function handleReadResource(uri) {
         const schema = pathComponents.pop();
         const tableName = pathComponents.pop();
         if (schema !== SCHEMA_PATH) {
-            throw new Error("Invalid resource URI");
+            throw new Error("无效的资源 URI");
         }
         // 使用适配器特定的查询来描述表结构
         const query = getDescribeTableQuery(tableName);
@@ -67,6 +67,6 @@ export async function handleReadResource(uri) {
         };
     }
     catch (error) {
-        throw new Error(`Error reading resource: ${error.message}`);
+        throw new Error(`读取资源失败: ${error.message}`);
     }
 }