@bytebase/dbhub 1.4.0 → 1.5.0

package/dist/mysql-XXIHWQGR.js

@@ -1,601 +0,0 @@
-import {
-  MissingDatabaseError,
-  getMySQLFamilyHealthCheck,
-  isClientSideTimeout,
-  isTiDBVersion,
-  parseQueryResultSets,
-  requireDatabaseInDSN,
-  withReadOnlyTransaction
-} from "./chunk-6SZKW6GD.js";
-import "./chunk-FU2ZJE4E.js";
-import {
-  quoteIdentifier
-} from "./chunk-X2EC47W4.js";
-import {
-  SQLRowLimiter,
-  closeQuietly
-} from "./chunk-YIGJHEU6.js";
-import "./chunk-ABTVMHD6.js";
-import {
-  ConnectorRegistry,
-  SafeURL,
-  obfuscateDSNPassword,
-  splitSQLStatements
-} from "./chunk-IXC4NQGC.js";
-
-// src/connectors/mysql/index.ts
-import mysql from "mysql2/promise";
-var MySQLDSNParser = class {
-  async parse(dsn, config) {
-    const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
-    const timezone = config?.timezone;
-    const charset = config?.charset;
-    const collation = config?.collation;
-    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 database = url.pathname ? url.pathname.substring(1) : "";
-      requireDatabaseInDSN(database, dsn, "MySQL");
-      const config2 = {
-        host: url.hostname,
-        port: url.port ? parseInt(url.port) : 3306,
-        database,
-        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 (timezone !== void 0) {
-        config2.timezone = timezone;
-      }
-      const charsetOrCollation = collation ?? charset;
-      if (charsetOrCollation !== void 0) {
-        config2.charset = charsetOrCollation;
-      }
-      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) {
-      if (error instanceof MissingDatabaseError) {
-        throw 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";
-    // TiDB speaks the MySQL protocol but rejects `START TRANSACTION READ ONLY`
-    // unless tidb_enable_noop_functions is on. Detected once at connect time.
-    this.supportsReadOnlyTransaction = true;
-  }
-  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 VERSION() AS version");
-      this.supportsReadOnlyTransaction = !isTiDBVersion(rows[0]?.version);
-    } catch (err) {
-      if (this.pool) {
-        const pool = this.pool;
-        this.pool = null;
-        await closeQuietly(() => pool.end());
-      }
-      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
-        WHERE SCHEMA_NAME NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')
-        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}
-        AND TABLE_TYPE = 'BASE TABLE'
-        ORDER BY TABLE_NAME
-      `,
-        queryParams
-      );
-      return rows.map((row) => row.TABLE_NAME);
-    } catch (error) {
-      console.error("Error getting tables:", error);
-      throw error;
-    }
-  }
-  async getViews(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}
-        AND TABLE_TYPE = 'VIEW'
-        ORDER BY TABLE_NAME
-      `,
-        queryParams
-      );
-      return rows.map((row) => row.TABLE_NAME);
-    } catch (error) {
-      console.error("Error getting views:", 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 getHealthCheck() {
-    if (!this.pool) {
-      throw new Error("Not connected to database");
-    }
-    const pool = this.pool;
-    return getMySQLFamilyHealthCheck(async (sql) => {
-      const [rows] = await pool.query(sql);
-      return rows;
-    });
-  }
-  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();
-        const quotedSchema = quoteIdentifier(schemaValue, "mysql");
-        const quotedProcName = quoteIdentifier(procedureName, "mysql");
-        if (procedure.procedure_type === "procedure") {
-          try {
-            const [defRows] = await this.pool.query(`
-              SHOW CREATE PROCEDURE ${quotedSchema}.${quotedProcName}
-            `);
-            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 ${quotedSchema}.${quotedProcName}
-            `);
-            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;
-  }
-  /**
-   * Default search scope = the database named in the DSN. DATABASE() returns
-   * null when the connection was opened without a database, in which case
-   * callers fall back to the full server-wide schema list.
-   */
-  async getDefaultSchema() {
-    if (!this.pool) {
-      throw new Error("Not connected to database");
-    }
-    const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
-    return rows[0]?.DB ?? null;
-  }
-  async executeSQL(sql, options, parameters) {
-    if (!this.pool) {
-      throw new Error("Not connected to database");
-    }
-    const conn = await this.pool.getConnection();
-    const threadId = conn.threadId;
-    let isConnectionPoisoned = false;
-    try {
-      return await withReadOnlyTransaction(
-        conn,
-        options.readonly,
-        this.supportsReadOnlyTransaction,
-        async () => {
-          const statements = splitSQLStatements(sql, "mysql");
-          let processedSQL = sql;
-          let probes = [];
-          if (options.maxRows) {
-            const rewrites = statements.map(
-              (statement) => SQLRowLimiter.applyMaxRowsWithTruncationProbe(statement, options.maxRows, "mysql")
-            );
-            probes = rewrites.map((rewrite) => rewrite.probeApplied);
-            processedSQL = rewrites.map((rewrite) => rewrite.sql).join("; ");
-            if (sql.trim().endsWith(";")) {
-              processedSQL += ";";
-            }
-          }
-          let results;
-          if (parameters && parameters.length > 0) {
-            results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs }, parameters);
-          } else {
-            results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs });
-          }
-          const [firstResult] = results;
-          const resultSets = parseQueryResultSets(firstResult, statements);
-          if (resultSets.length === probes.length) {
-            resultSets.forEach(
-              (set, index) => SQLRowLimiter.flagTruncation(set, options.maxRows, probes[index])
-            );
-          }
-          return { resultSets };
-        }
-      );
-    } catch (error) {
-      if (isClientSideTimeout(error)) {
-        isConnectionPoisoned = true;
-        await this.killQuery(threadId);
-      }
-      throw error;
-    } finally {
-      if (isConnectionPoisoned) {
-        conn.destroy();
-      } else {
-        conn.release();
-      }
-    }
-  }
-  /**
-   * Best-effort server-side kill for a query abandoned by mysql2's client-side
-   * timeout. Uses a separate connection: the original connection's command
-   * queue is stuck behind the abandoned statement (see isClientSideTimeout)
-   * and cannot itself be used to send KILL QUERY.
-   *
-   * Bounded by its own short timeout, independent of the user's (possibly
-   * long or unset) query_timeout — KILL QUERY is metadata-only and should
-   * return almost immediately on a healthy server, so cleanup must not stall
-   * indefinitely if it doesn't.
-   */
-  async killQuery(threadId) {
-    if (!this.pool) return;
-    let killer;
-    let killerPoisoned = false;
-    try {
-      killer = await this.pool.getConnection();
-      await killer.query({ sql: `KILL QUERY ${threadId}`, timeout: _MySQLConnector.KILL_QUERY_TIMEOUT_MS });
-    } catch (error) {
-      killerPoisoned = isClientSideTimeout(error);
-    } finally {
-      if (killer) {
-        if (killerPoisoned) {
-          killer.destroy();
-        } else {
-          killer.release();
-        }
-      }
-    }
-  }
-};
-// Bounds the KILL QUERY cleanup call issued after a client-side query
-// timeout; see killQuery.
-_MySQLConnector.KILL_QUERY_TIMEOUT_MS = 5e3;
-var MySQLConnector = _MySQLConnector;
-var mysqlConnector = new MySQLConnector();
-ConnectorRegistry.register(mysqlConnector);
-export {
-  MySQLConnector
-};