@zz1996/dbhub-dameng 0.1.0

package/dist/sqlserver-OE4SFH4B.js

@@ -0,0 +1,587 @@
+import {
+  isDriverNotInstalled
+} from "./chunk-WVVMH6FJ.js";
+import {
+  SQLRowLimiter
+} from "./chunk-ZNQTMARG.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  stripCommentsAndStrings
+} from "./chunk-SQA2ISDE.js";
+
+// src/connectors/sqlserver/index.ts
+import sql from "mssql";
+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": {
+          let DefaultAzureCredential;
+          try {
+            ({ DefaultAzureCredential } = await import("@azure/identity"));
+          } catch (importError) {
+            if (isDriverNotInstalled(importError, "@azure/identity")) {
+              throw new Error(
+                'Azure AD authentication requires the "@azure/identity" package. Install it with: pnpm add @azure/identity'
+              );
+            }
+            throw importError;
+          }
+          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
+          AND TABLE_TYPE = 'BASE TABLE'
+          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 getViews(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
+          AND TABLE_TYPE = 'VIEW'
+          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 views: ${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");
+    }
+    const afterNoise = sqlQuery.slice(
+      sqlQuery.match(_SQLServerConnector.LEADING_NOISE)[0].length
+    );
+    if (/^explain\b/i.test(afterNoise)) {
+      return this.explainQuery(afterNoise.slice("explain".length).trim());
+    }
+    try {
+      let processedSQL = sqlQuery;
+      if (options.maxRows) {
+        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
+      }
+      const request = this.connection.request();
+      const messages = [];
+      request.on(
+        "info",
+        (info) => {
+          messages.push({
+            text: info.message,
+            // SQL Server reports severity as a numeric class; info messages are < 10.
+            severity: info.class !== void 0 ? String(info.class) : void 0,
+            code: info.number,
+            line: info.lineNumber
+          });
+        }
+      );
+      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,
+        ...messages.length > 0 ? { messages } : {}
+      };
+    } catch (error) {
+      throw new Error(`Failed to execute query: ${error.message}`);
+    }
+  }
+  /**
+   * Return the estimated execution plan for a query using SHOWPLAN_XML.
+   *
+   * SHOWPLAN_XML compiles the statement and returns its plan without executing
+   * it, but it has two constraints: `SET SHOWPLAN_XML ON` must be the only
+   * statement in its batch, and the setting is session scoped. The shared pool
+   * hands out a fresh connection per request() and an open transaction
+   * suppresses SHOWPLAN, so neither can carry the setting to a follow-up query.
+   *
+   * We therefore run the SET / query pair on a short-lived, single-connection
+   * pool built from the same config. The dedicated session keeps SHOWPLAN state
+   * off the shared pool, so a concurrent query can never land on a connection
+   * with SHOWPLAN enabled (which would return a plan instead of its results).
+   */
+  async explainQuery(innerQuery) {
+    const cleaned = stripCommentsAndStrings(innerQuery, "sqlserver").trim();
+    if (!cleaned) {
+      throw new Error("EXPLAIN requires a statement to analyze");
+    }
+    if (/\bset\s+showplan/i.test(cleaned)) {
+      throw new Error("EXPLAIN does not support SET SHOWPLAN statements");
+    }
+    if (!this.config) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    const explainPool = new sql.ConnectionPool({
+      ...this.config,
+      pool: { ...this.config.pool, max: 1, min: 1 }
+    });
+    try {
+      await explainPool.connect();
+      await explainPool.request().batch("SET SHOWPLAN_XML ON");
+      const planResult = await explainPool.request().batch(innerQuery);
+      const planRow = planResult.recordset?.[0];
+      const planXml = planRow ? Object.values(planRow)[0] : null;
+      return {
+        rows: planXml != null ? [{ plan: planXml }] : [],
+        rowCount: planXml != null ? 1 : 0
+      };
+    } catch (error) {
+      throw new Error(`Failed to explain query: ${error.message}`);
+    } finally {
+      await explainPool.close();
+    }
+  }
+};
+/**
+ * Leading whitespace and SQL comments to skip before looking for a keyword.
+ * The read-only validator strips comments before checking the first keyword,
+ * so the connector must skip them too; otherwise an EXPLAIN preceded by a
+ * comment passes validation but reaches the server untranslated.
+ */
+_SQLServerConnector.LEADING_NOISE = /^(?:\s+|--[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)*/;
+var SQLServerConnector = _SQLServerConnector;
+var sqlServerConnector = new SQLServerConnector();
+ConnectorRegistry.register(sqlServerConnector);
+export {
+  SQLServerConnector,
+  SQLServerDSNParser
+};

package/docs/README.md

@@ -0,0 +1,14 @@
+# DBHub Documentation
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mint) to preview documentation locally:
+
+```bash
+npm i -g mint
+```
+
+Run the following command at the root of your documentation (where `docs.json` is located):
+
+```bash
+cd docs
+mint dev
+```