@bytebase/dbhub 0.20.0 → 0.21.1

package/dist/mysql-I35IQ2GH.js

@@ -0,0 +1,469 @@
+import {
+  extractAffectedRows,
+  parseQueryResults
+} from "./chunk-RTB262PR.js";
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements
+} from "./chunk-C7WEAPX4.js";
+
+// src/connectors/mysql/index.ts
+import mysql from "mysql2/promise";
+var MySQLDSNParser = class {
+  async parse(dsn, config) {
+    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid MySQL DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      const config2 = {
+        host: url.hostname,
+        port: url.port ? parseInt(url.port) : 3306,
+        database: url.pathname ? url.pathname.substring(1) : "",
+        // Remove leading '/' if exists
+        user: url.username,
+        password: url.password,
+        multipleStatements: true,
+        // Enable native multi-statement support
+        supportBigNumbers: true
+        // Return BIGINT as string when value exceeds Number.MAX_SAFE_INTEGER
+      };
+      url.forEachSearchParam((value, key) => {
+        if (key === "sslmode") {
+          if (value === "disable") {
+            config2.ssl = void 0;
+          } else if (value === "require") {
+            config2.ssl = { rejectUnauthorized: false };
+          } else {
+            config2.ssl = {};
+          }
+        }
+      });
+      if (connectionTimeoutSeconds !== void 0) {
+        config2.connectTimeout = connectionTimeoutSeconds * 1e3;
+      }
+      if (url.password && url.password.includes("X-Amz-Credential")) {
+        config2.authPlugins = {
+          mysql_clear_password: () => () => {
+            return Buffer.from(url.password + "\0");
+          }
+        };
+        if (config2.ssl === void 0) {
+          config2.ssl = { rejectUnauthorized: false };
+        }
+      }
+      return config2;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "mysql://root:password@localhost:3306/mysql?sslmode=require";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("mysql://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var MySQLConnector = class _MySQLConnector {
+  constructor() {
+    this.id = "mysql";
+    this.name = "MySQL";
+    this.dsnParser = new MySQLDSNParser();
+    this.pool = null;
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _MySQLConnector();
+  }
+  async connect(dsn, initScript, config) {
+    try {
+      const connectionOptions = await this.dsnParser.parse(dsn, config);
+      this.pool = mysql.createPool(connectionOptions);
+      if (config?.queryTimeoutSeconds !== void 0) {
+        this.queryTimeoutMs = config.queryTimeoutSeconds * 1e3;
+      }
+      const [rows] = await this.pool.query("SELECT 1");
+    } catch (err) {
+      console.error("Failed to connect to MySQL database:", err);
+      throw err;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getSchemas() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const [rows] = await this.pool.query(`
+        SELECT SCHEMA_NAME 
+        FROM INFORMATION_SCHEMA.SCHEMATA
+        ORDER BY SCHEMA_NAME
+      `);
+      return rows.map((row) => row.SCHEMA_NAME);
+    } catch (error) {
+      console.error("Error getting schemas:", error);
+      throw error;
+    }
+  }
+  async getTables(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const [rows] = await this.pool.query(
+        `
+        SELECT TABLE_NAME 
+        FROM INFORMATION_SCHEMA.TABLES 
+        ${schemaClause}
+        ORDER BY TABLE_NAME
+      `,
+        queryParams
+      );
+      return rows.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      console.error("Error getting tables:", error);
+      throw error;
+    }
+  }
+  async tableExists(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT COUNT(*) AS COUNT
+        FROM INFORMATION_SCHEMA.TABLES 
+        ${schemaClause} 
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      return rows[0].COUNT > 0;
+    } catch (error) {
+      console.error("Error checking if table exists:", error);
+      throw error;
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "TABLE_SCHEMA = ?" : "TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [indexRows] = await this.pool.query(
+        `
+        SELECT 
+          INDEX_NAME,
+          COLUMN_NAME,
+          NON_UNIQUE,
+          SEQ_IN_INDEX
+        FROM 
+          INFORMATION_SCHEMA.STATISTICS 
+        WHERE 
+          ${schemaClause}
+          AND TABLE_NAME = ? 
+        ORDER BY 
+          INDEX_NAME, 
+          SEQ_IN_INDEX
+      `,
+        queryParams
+      );
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of indexRows) {
+        const indexName = row.INDEX_NAME;
+        const columnName = row.COLUMN_NAME;
+        const isUnique = row.NON_UNIQUE === 0;
+        const isPrimary = indexName === "PRIMARY";
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        const indexInfo = indexMap.get(indexName);
+        indexInfo.columns.push(columnName);
+      }
+      const results = [];
+      indexMap.forEach((indexInfo, indexName) => {
+        results.push({
+          index_name: indexName,
+          column_names: indexInfo.columns,
+          is_unique: indexInfo.is_unique,
+          is_primary: indexInfo.is_primary
+        });
+      });
+      return results;
+    } catch (error) {
+      console.error("Error getting table indexes:", error);
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
+          IS_NULLABLE as is_nullable,
+          COLUMN_DEFAULT as column_default,
+          COLUMN_COMMENT as description
+        FROM INFORMATION_SCHEMA.COLUMNS
+        ${schemaClause}
+        AND TABLE_NAME = ?
+        ORDER BY ORDINAL_POSITION
+      `,
+        queryParams
+      );
+      return rows.map((row) => ({
+        ...row,
+        description: row.description || null
+      }));
+    } catch (error) {
+      console.error("Error getting table schema:", error);
+      throw error;
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT TABLE_COMMENT
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length > 0) {
+        return rows[0].TABLE_COMMENT || null;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND ROUTINE_TYPE = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND ROUTINE_TYPE = 'PROCEDURE'";
+      }
+      const [rows] = await this.pool.query(
+        `
+        SELECT ROUTINE_NAME
+        FROM INFORMATION_SCHEMA.ROUTINES
+        ${schemaClause}${typeFilter}
+        ORDER BY ROUTINE_NAME
+      `,
+        queryParams
+      );
+      return rows.map((row) => row.ROUTINE_NAME);
+    } catch (error) {
+      console.error("Error getting stored procedures:", error);
+      throw error;
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE r.ROUTINE_SCHEMA = ?" : "WHERE r.ROUTINE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, procedureName] : [procedureName];
+      const [rows] = await this.pool.query(
+        `
+        SELECT 
+          r.ROUTINE_NAME AS procedure_name,
+          CASE 
+            WHEN r.ROUTINE_TYPE = 'PROCEDURE' THEN 'procedure'
+            ELSE 'function'
+          END AS procedure_type,
+          LOWER(r.ROUTINE_TYPE) AS routine_type,
+          r.ROUTINE_DEFINITION,
+          r.DTD_IDENTIFIER AS return_type,
+          (
+            SELECT GROUP_CONCAT(
+              CONCAT(p.PARAMETER_NAME, ' ', p.PARAMETER_MODE, ' ', p.DATA_TYPE)
+              ORDER BY p.ORDINAL_POSITION
+              SEPARATOR ', '
+            )
+            FROM INFORMATION_SCHEMA.PARAMETERS p
+            WHERE p.SPECIFIC_SCHEMA = r.ROUTINE_SCHEMA
+            AND p.SPECIFIC_NAME = r.ROUTINE_NAME
+            AND p.PARAMETER_NAME IS NOT NULL
+          ) AS parameter_list
+        FROM INFORMATION_SCHEMA.ROUTINES r
+        ${schemaClause}
+        AND r.ROUTINE_NAME = ?
+      `,
+        queryParams
+      );
+      if (rows.length === 0) {
+        const schemaName = schema || "current schema";
+        throw new Error(`Stored procedure '${procedureName}' not found in ${schemaName}`);
+      }
+      const procedure = rows[0];
+      let definition = procedure.ROUTINE_DEFINITION;
+      try {
+        const schemaValue = schema || await this.getCurrentSchema();
+        if (procedure.procedure_type === "procedure") {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE PROCEDURE ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Procedure"];
+            }
+          } catch (err) {
+            console.error(`Error getting procedure definition with SHOW CREATE: ${err}`);
+          }
+        } else {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE FUNCTION ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Function"];
+            }
+          } catch (innerErr) {
+            console.error(`Error getting function definition with SHOW CREATE: ${innerErr}`);
+          }
+        }
+        if (!definition) {
+          const [bodyRows] = await this.pool.query(
+            `
+            SELECT ROUTINE_DEFINITION, ROUTINE_BODY 
+            FROM INFORMATION_SCHEMA.ROUTINES
+            WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ?
+          `,
+            [schemaValue, procedureName]
+          );
+          if (bodyRows && bodyRows.length > 0) {
+            if (bodyRows[0].ROUTINE_DEFINITION) {
+              definition = bodyRows[0].ROUTINE_DEFINITION;
+            } else if (bodyRows[0].ROUTINE_BODY) {
+              definition = bodyRows[0].ROUTINE_BODY;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error getting procedure/function details: ${error}`);
+      }
+      return {
+        procedure_name: procedure.procedure_name,
+        procedure_type: procedure.procedure_type,
+        language: "sql",
+        // MySQL procedures are generally in SQL
+        parameter_list: procedure.parameter_list || "",
+        return_type: procedure.routine_type === "function" ? procedure.return_type : void 0,
+        definition: definition || void 0
+      };
+    } catch (error) {
+      console.error("Error getting stored procedure detail:", error);
+      throw error;
+    }
+  }
+  // Helper method to get current schema (database) name
+  async getCurrentSchema() {
+    const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
+    return rows[0].DB;
+  }
+  async executeSQL(sql, options, parameters) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const conn = await this.pool.getConnection();
+    try {
+      let processedSQL = sql;
+      if (options.maxRows) {
+        const statements = splitSQLStatements(sql, "mysql");
+        const processedStatements = statements.map(
+          (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
+        );
+        processedSQL = processedStatements.join("; ");
+        if (sql.trim().endsWith(";")) {
+          processedSQL += ";";
+        }
+      }
+      let results;
+      if (parameters && parameters.length > 0) {
+        try {
+          results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs }, parameters);
+        } catch (error) {
+          console.error(`[MySQL executeSQL] ERROR: ${error.message}`);
+          console.error(`[MySQL executeSQL] SQL: ${processedSQL}`);
+          console.error(`[MySQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+          throw error;
+        }
+      } else {
+        results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs });
+      }
+      const [firstResult] = results;
+      const rows = parseQueryResults(firstResult);
+      const rowCount = extractAffectedRows(firstResult);
+      return { rows, rowCount };
+    } catch (error) {
+      console.error("Error executing query:", error);
+      throw error;
+    } finally {
+      conn.release();
+    }
+  }
+};
+var mysqlConnector = new MySQLConnector();
+ConnectorRegistry.register(mysqlConnector);
+export {
+  MySQLConnector
+};