@bytebase/dbhub 0.19.1 → 0.21.0

package/dist/sqlserver-FDBRUELV.js

@@ -0,0 +1,479 @@
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword
+} from "./chunk-C7WEAPX4.js";
+
+// src/connectors/sqlserver/index.ts
+import sql from "mssql";
+import { DefaultAzureCredential } from "@azure/identity";
+var SQLServerDSNParser = class {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
+    const queryTimeoutSeconds = config?.queryTimeoutSeconds;
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid SQL Server DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      const options = {};
+      url.forEachSearchParam((value, key) => {
+        if (key === "authentication") {
+          options.authentication = value;
+        } else if (key === "sslmode") {
+          options.sslmode = value;
+        } else if (key === "instanceName") {
+          options.instanceName = value;
+        } else if (key === "domain") {
+          options.domain = value;
+        }
+      });
+      if (options.authentication === "ntlm" && !options.domain) {
+        throw new Error("NTLM authentication requires 'domain' parameter");
+      }
+      if (options.domain && options.authentication !== "ntlm") {
+        throw new Error("Parameter 'domain' requires 'authentication=ntlm'");
+      }
+      if (options.sslmode) {
+        if (options.sslmode === "disable") {
+          options.encrypt = false;
+          options.trustServerCertificate = false;
+        } else if (options.sslmode === "require") {
+          options.encrypt = true;
+          options.trustServerCertificate = true;
+        }
+      }
+      const config2 = {
+        server: url.hostname,
+        port: url.port ? parseInt(url.port) : 1433,
+        // Default SQL Server port
+        database: url.pathname ? url.pathname.substring(1) : "",
+        // Remove leading slash
+        options: {
+          encrypt: options.encrypt ?? false,
+          // Default to unencrypted for development
+          trustServerCertificate: options.trustServerCertificate ?? false,
+          ...connectionTimeoutSeconds !== void 0 && {
+            connectTimeout: connectionTimeoutSeconds * 1e3
+          },
+          ...queryTimeoutSeconds !== void 0 && {
+            requestTimeout: queryTimeoutSeconds * 1e3
+          },
+          instanceName: options.instanceName
+          // Add named instance support
+        }
+      };
+      switch (options.authentication) {
+        case "azure-active-directory-access-token": {
+          try {
+            const credential = new DefaultAzureCredential();
+            const token = await credential.getToken("https://database.windows.net/");
+            config2.authentication = {
+              type: "azure-active-directory-access-token",
+              options: {
+                token: token.token
+              }
+            };
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to get Azure AD token: ${errorMessage}`);
+          }
+          break;
+        }
+        case "ntlm":
+          config2.authentication = {
+            type: "ntlm",
+            options: {
+              domain: options.domain,
+              userName: url.username,
+              password: url.password
+            }
+          };
+          break;
+        default:
+          config2.user = url.username;
+          config2.password = url.password;
+          break;
+      }
+      return config2;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse SQL Server DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "sqlserver://username:password@localhost:1433/database?sslmode=disable&instanceName=INSTANCE1";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("sqlserver://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var SQLServerConnector = class _SQLServerConnector {
+  constructor() {
+    this.id = "sqlserver";
+    this.name = "SQL Server";
+    this.dsnParser = new SQLServerDSNParser();
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _SQLServerConnector();
+  }
+  async connect(dsn, initScript, config) {
+    try {
+      this.config = await this.dsnParser.parse(dsn, config);
+      if (!this.config.options) {
+        this.config.options = {};
+      }
+      this.connection = await new sql.ConnectionPool(this.config).connect();
+    } catch (error) {
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.close();
+      this.connection = void 0;
+    }
+  }
+  async getSchemas() {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const result = await this.connection.request().query(`
+          SELECT SCHEMA_NAME
+          FROM INFORMATION_SCHEMA.SCHEMATA
+          ORDER BY SCHEMA_NAME
+      `);
+      return result.recordset.map((row) => row.SCHEMA_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get schemas: ${error.message}`);
+    }
+  }
+  async getTables(schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = @schema
+          ORDER BY TABLE_NAME
+      `;
+      const result = await request.query(query);
+      return result.recordset.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get tables: ${error.message}`);
+    }
+  }
+  async tableExists(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT COUNT(*) as count
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_NAME = @tableName
+            AND TABLE_SCHEMA = @schema
+      `;
+      const result = await request.query(query);
+      return result.recordset[0].count > 0;
+    } catch (error) {
+      throw new Error(`Failed to check if table exists: ${error.message}`);
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT i.name AS index_name,
+                 i.is_unique,
+                 i.is_primary_key,
+                 c.name AS column_name,
+                 ic.key_ordinal
+          FROM sys.indexes i
+                   INNER JOIN
+               sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+                   INNER JOIN
+               sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+                   INNER JOIN
+               sys.tables t ON i.object_id = t.object_id
+                   INNER JOIN
+               sys.schemas s ON t.schema_id = s.schema_id
+          WHERE t.name = @tableName
+            AND s.name = @schema
+          ORDER BY i.name,
+                   ic.key_ordinal
+      `;
+      const result = await request.query(query);
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of result.recordset) {
+        const indexName = row.index_name;
+        const columnName = row.column_name;
+        const isUnique = !!row.is_unique;
+        const isPrimary = !!row.is_primary_key;
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        const indexInfo = indexMap.get(indexName);
+        indexInfo.columns.push(columnName);
+      }
+      const indexes = [];
+      indexMap.forEach((info, name) => {
+        indexes.push({
+          index_name: name,
+          column_names: info.columns,
+          is_unique: info.is_unique,
+          is_primary: info.is_primary
+        });
+      });
+      return indexes;
+    } catch (error) {
+      throw new Error(`Failed to get indexes for table ${tableName}: ${error.message}`);
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT c.COLUMN_NAME as    column_name,
+                 c.DATA_TYPE as      data_type,
+                 c.IS_NULLABLE as    is_nullable,
+                 c.COLUMN_DEFAULT as column_default,
+                 ep.value as         description
+          FROM INFORMATION_SCHEMA.COLUMNS c
+          LEFT JOIN sys.columns sc
+            ON sc.name = c.COLUMN_NAME
+            AND sc.object_id = OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME))
+          LEFT JOIN sys.extended_properties ep
+            ON ep.major_id = sc.object_id
+            AND ep.minor_id = sc.column_id
+            AND ep.name = 'MS_Description'
+          WHERE c.TABLE_NAME = @tableName
+            AND c.TABLE_SCHEMA = @schema
+          ORDER BY c.ORDINAL_POSITION
+      `;
+      const result = await request.query(query);
+      return result.recordset.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
+    } catch (error) {
+      throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT ep.value as table_comment
+          FROM sys.extended_properties ep
+          JOIN sys.tables t ON ep.major_id = t.object_id
+          JOIN sys.schemas s ON t.schema_id = s.schema_id
+          WHERE ep.minor_id = 0
+            AND ep.name = 'MS_Description'
+            AND t.name = @tableName
+            AND s.name = @schema
+      `;
+      const result = await request.query(query);
+      if (result.recordset.length > 0) {
+        return result.recordset[0].table_comment || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      let typeFilter;
+      if (routineType === "function") {
+        typeFilter = "AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = "AND ROUTINE_TYPE = 'PROCEDURE'";
+      } else {
+        typeFilter = "AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')";
+      }
+      const query = `
+          SELECT ROUTINE_NAME
+          FROM INFORMATION_SCHEMA.ROUTINES
+          WHERE ROUTINE_SCHEMA = @schema
+            ${typeFilter}
+          ORDER BY ROUTINE_NAME
+      `;
+      const result = await request.query(query);
+      return result.recordset.map((row) => row.ROUTINE_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get stored procedures: ${error.message}`);
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("procedureName", sql.VarChar, procedureName).input("schema", sql.VarChar, schemaToUse);
+      const routineQuery = `
+          SELECT ROUTINE_NAME as procedure_name,
+                 ROUTINE_TYPE,
+                 DATA_TYPE    as return_data_type
+          FROM INFORMATION_SCHEMA.ROUTINES
+          WHERE ROUTINE_NAME = @procedureName
+            AND ROUTINE_SCHEMA = @schema
+      `;
+      const routineResult = await request.query(routineQuery);
+      if (routineResult.recordset.length === 0) {
+        throw new Error(`Stored procedure '${procedureName}' not found in schema '${schemaToUse}'`);
+      }
+      const routine = routineResult.recordset[0];
+      const parameterQuery = `
+          SELECT PARAMETER_NAME,
+                 PARAMETER_MODE,
+                 DATA_TYPE,
+                 CHARACTER_MAXIMUM_LENGTH,
+                 ORDINAL_POSITION
+          FROM INFORMATION_SCHEMA.PARAMETERS
+          WHERE SPECIFIC_NAME = @procedureName
+            AND SPECIFIC_SCHEMA = @schema
+          ORDER BY ORDINAL_POSITION
+      `;
+      const parameterResult = await request.query(parameterQuery);
+      let parameterList = "";
+      if (parameterResult.recordset.length > 0) {
+        parameterList = parameterResult.recordset.map(
+          (param) => {
+            const lengthStr = param.CHARACTER_MAXIMUM_LENGTH > 0 ? `(${param.CHARACTER_MAXIMUM_LENGTH})` : "";
+            return `${param.PARAMETER_NAME} ${param.PARAMETER_MODE} ${param.DATA_TYPE}${lengthStr}`;
+          }
+        ).join(", ");
+      }
+      const definitionQuery = `
+          SELECT definition
+          FROM sys.sql_modules sm
+                   JOIN sys.objects o ON sm.object_id = o.object_id
+                   JOIN sys.schemas s ON o.schema_id = s.schema_id
+          WHERE o.name = @procedureName
+            AND s.name = @schema
+      `;
+      const definitionResult = await request.query(definitionQuery);
+      let definition = void 0;
+      if (definitionResult.recordset.length > 0) {
+        definition = definitionResult.recordset[0].definition;
+      }
+      return {
+        procedure_name: routine.procedure_name,
+        procedure_type: routine.ROUTINE_TYPE === "PROCEDURE" ? "procedure" : "function",
+        language: "sql",
+        // SQL Server procedures are typically in T-SQL
+        parameter_list: parameterList,
+        return_type: routine.ROUTINE_TYPE === "FUNCTION" ? routine.return_data_type : void 0,
+        definition
+      };
+    } catch (error) {
+      throw new Error(`Failed to get stored procedure details: ${error.message}`);
+    }
+  }
+  async executeSQL(sqlQuery, options, parameters) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      let processedSQL = sqlQuery;
+      if (options.maxRows) {
+        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
+      }
+      const request = this.connection.request();
+      if (parameters && parameters.length > 0) {
+        parameters.forEach((param, index) => {
+          const paramName = `p${index + 1}`;
+          if (typeof param === "string") {
+            request.input(paramName, sql.VarChar, param);
+          } else if (typeof param === "number") {
+            if (Number.isInteger(param)) {
+              request.input(paramName, sql.Int, param);
+            } else {
+              request.input(paramName, sql.Float, param);
+            }
+          } else if (typeof param === "boolean") {
+            request.input(paramName, sql.Bit, param);
+          } else if (param === null || param === void 0) {
+            request.input(paramName, sql.VarChar, param);
+          } else if (Array.isArray(param)) {
+            request.input(paramName, sql.VarChar, JSON.stringify(param));
+          } else {
+            request.input(paramName, sql.VarChar, JSON.stringify(param));
+          }
+        });
+      }
+      let result;
+      try {
+        result = await request.query(processedSQL);
+      } catch (error) {
+        if (parameters && parameters.length > 0) {
+          console.error(`[SQL Server executeSQL] ERROR: ${error.message}`);
+          console.error(`[SQL Server executeSQL] SQL: ${processedSQL}`);
+          console.error(`[SQL Server executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+        }
+        throw error;
+      }
+      return {
+        rows: result.recordset || [],
+        rowCount: result.rowsAffected[0] || 0
+      };
+    } catch (error) {
+      throw new Error(`Failed to execute query: ${error.message}`);
+    }
+  }
+};
+var sqlServerConnector = new SQLServerConnector();
+ConnectorRegistry.register(sqlServerConnector);
+export {
+  SQLServerConnector,
+  SQLServerDSNParser
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
@@ -43,17 +43,19 @@
     "@azure/identity": "^4.8.0",
     "@iarna/toml": "^2.2.5",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "better-sqlite3": "^11.9.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
-    "mariadb": "^3.4.0",
-    "mssql": "^11.0.1",
-    "mysql2": "^3.13.0",
-    "pg": "^8.13.3",
     "ssh-config": "^5.0.3",
     "ssh2": "^1.16.0",
     "zod": "^3.24.2"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^11.9.0",
+    "mariadb": "^3.4.0",
+    "mssql": "^11.0.1",
+    "mysql2": "^3.13.0",
+    "pg": "^8.13.3"
+  },
   "devDependencies": {
     "@testcontainers/mariadb": "^11.0.3",
     "@testcontainers/mssqlserver": "^11.0.3",