@bytebase/dbhub 0.19.1 → 0.21.0

package/dist/postgres-B7YSSZMH.js

@@ -0,0 +1,480 @@
+import {
+  quoteIdentifier
+} from "./chunk-JFWX35TB.js";
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements
+} from "./chunk-C7WEAPX4.js";
+
+// src/connectors/postgres/index.ts
+import pg from "pg";
+var { Pool } = pg;
+var PostgresDSNParser = 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 PostgreSQL DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      const poolConfig = {
+        host: url.hostname,
+        port: url.port ? parseInt(url.port) : 5432,
+        database: url.pathname ? url.pathname.substring(1) : "",
+        // Remove leading '/' if exists
+        user: url.username,
+        password: url.password
+      };
+      url.forEachSearchParam((value, key) => {
+        if (key === "sslmode") {
+          if (value === "disable") {
+            poolConfig.ssl = false;
+          } else if (value === "require") {
+            poolConfig.ssl = { rejectUnauthorized: false };
+          } else {
+            poolConfig.ssl = true;
+          }
+        }
+      });
+      if (connectionTimeoutSeconds !== void 0) {
+        poolConfig.connectionTimeoutMillis = connectionTimeoutSeconds * 1e3;
+      }
+      if (queryTimeoutSeconds !== void 0) {
+        poolConfig.query_timeout = queryTimeoutSeconds * 1e3;
+      }
+      return poolConfig;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse PostgreSQL DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "postgres://postgres:password@localhost:5432/postgres?sslmode=require";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("postgres://") || dsn.startsWith("postgresql://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var PostgresConnector = class _PostgresConnector {
+  constructor() {
+    this.id = "postgres";
+    this.name = "PostgreSQL";
+    this.dsnParser = new PostgresDSNParser();
+    this.pool = null;
+    // Source ID is set by ConnectorManager after cloning
+    this.sourceId = "default";
+    // Default schema for discovery methods (first entry from search_path, or "public")
+    this.defaultSchema = "public";
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _PostgresConnector();
+  }
+  async connect(dsn, initScript, config) {
+    this.defaultSchema = "public";
+    try {
+      const poolConfig = await this.dsnParser.parse(dsn, config);
+      if (config?.readonly) {
+        poolConfig.options = (poolConfig.options || "") + " -c default_transaction_read_only=on";
+      }
+      if (config?.searchPath) {
+        const schemas = config.searchPath.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        if (schemas.length > 0) {
+          this.defaultSchema = schemas[0];
+          const quotedSchemas = schemas.map((s) => quoteIdentifier(s, "postgres"));
+          const optionsValue = quotedSchemas.join(",").replace(/\\/g, "\\\\").replace(/ /g, "\\ ");
+          poolConfig.options = (poolConfig.options || "") + ` -c search_path=${optionsValue}`;
+        }
+      }
+      this.pool = new Pool(poolConfig);
+      const client = await this.pool.connect();
+      client.release();
+    } catch (err) {
+      console.error("Failed to connect to PostgreSQL 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");
+    }
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
+        SELECT schema_name
+        FROM information_schema.schemata
+        WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+        ORDER BY schema_name
+      `);
+      return result.rows.map((row) => row.schema_name);
+    } finally {
+      client.release();
+    }
+  }
+  async getTables(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = $1
+        ORDER BY table_name
+      `,
+        [schemaToUse]
+      );
+      return result.rows.map((row) => row.table_name);
+    } finally {
+      client.release();
+    }
+  }
+  async tableExists(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_schema = $1 
+          AND table_name = $2
+        )
+      `,
+        [schemaToUse, tableName]
+      );
+      return result.rows[0].exists;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT 
+          i.relname as index_name,
+          array_agg(a.attname) as column_names,
+          ix.indisunique as is_unique,
+          ix.indisprimary as is_primary
+        FROM 
+          pg_class t,
+          pg_class i,
+          pg_index ix,
+          pg_attribute a,
+          pg_namespace ns
+        WHERE 
+          t.oid = ix.indrelid
+          AND i.oid = ix.indexrelid
+          AND a.attrelid = t.oid
+          AND a.attnum = ANY(ix.indkey)
+          AND t.relkind = 'r'
+          AND t.relname = $1
+          AND ns.oid = t.relnamespace
+          AND ns.nspname = $2
+        GROUP BY 
+          i.relname, 
+          ix.indisunique,
+          ix.indisprimary
+        ORDER BY 
+          i.relname
+      `,
+        [tableName, schemaToUse]
+      );
+      return result.rows.map((row) => ({
+        index_name: row.index_name,
+        column_names: row.column_names,
+        is_unique: row.is_unique,
+        is_primary: row.is_primary
+      }));
+    } finally {
+      client.release();
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT
+          c.column_name,
+          c.data_type,
+          c.is_nullable,
+          c.column_default,
+          pgd.description
+        FROM information_schema.columns c
+        LEFT JOIN pg_catalog.pg_namespace nsp
+          ON nsp.nspname = c.table_schema
+        LEFT JOIN pg_catalog.pg_class cls
+          ON cls.relnamespace = nsp.oid
+          AND cls.relname = c.table_name
+        LEFT JOIN pg_catalog.pg_description pgd
+          ON pgd.objoid = cls.oid
+          AND pgd.objsubid = c.ordinal_position
+        WHERE c.table_schema = $1
+        AND c.table_name = $2
+        ORDER BY c.ordinal_position
+      `,
+        [schemaToUse, tableName]
+      );
+      return result.rows;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableRowCount(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT c.reltuples::bigint as count
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        const count = Number(result.rows[0].count);
+        return count >= 0 ? count : null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT obj_description(c.oid) as table_comment
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+        AND n.nspname = $2
+        AND c.relkind IN ('r','p','m','f')
+      `,
+        [tableName, schemaToUse]
+      );
+      if (result.rows.length > 0) {
+        return result.rows[0].table_comment || null;
+      }
+      return null;
+    } finally {
+      client.release();
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const params = [schemaToUse];
+      let typeFilter = "";
+      if (routineType === "function") {
+        typeFilter = " AND routine_type = 'FUNCTION'";
+      } else if (routineType === "procedure") {
+        typeFilter = " AND routine_type = 'PROCEDURE'";
+      }
+      const result = await client.query(
+        `
+        SELECT
+          routine_name
+        FROM information_schema.routines
+        WHERE routine_schema = $1${typeFilter}
+        ORDER BY routine_name
+      `,
+        params
+      );
+      return result.rows.map((row) => row.routine_name);
+    } finally {
+      client.release();
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT 
+          routine_name as procedure_name,
+          routine_type,
+          CASE WHEN routine_type = 'PROCEDURE' THEN 'procedure' ELSE 'function' END as procedure_type,
+          external_language as language,
+          data_type as return_type,
+          routine_definition as definition,
+          (
+            SELECT string_agg(
+              parameter_name || ' ' || 
+              parameter_mode || ' ' || 
+              data_type,
+              ', '
+            )
+            FROM information_schema.parameters
+            WHERE specific_schema = $1
+            AND specific_name = $2
+            AND parameter_name IS NOT NULL
+          ) as parameter_list
+        FROM information_schema.routines
+        WHERE routine_schema = $1
+        AND routine_name = $2
+      `,
+        [schemaToUse, procedureName]
+      );
+      if (result.rows.length === 0) {
+        throw new Error(`Stored procedure '${procedureName}' not found in schema '${schemaToUse}'`);
+      }
+      const procedure = result.rows[0];
+      let definition = procedure.definition;
+      try {
+        const oidResult = await client.query(
+          `
+          SELECT p.oid, p.prosrc
+          FROM pg_proc p
+          JOIN pg_namespace n ON p.pronamespace = n.oid
+          WHERE p.proname = $1
+          AND n.nspname = $2
+        `,
+          [procedureName, schemaToUse]
+        );
+        if (oidResult.rows.length > 0) {
+          if (!definition) {
+            const oid = oidResult.rows[0].oid;
+            const defResult = await client.query(`SELECT pg_get_functiondef($1)`, [oid]);
+            if (defResult.rows.length > 0) {
+              definition = defResult.rows[0].pg_get_functiondef;
+            } else {
+              definition = oidResult.rows[0].prosrc;
+            }
+          }
+        }
+      } catch (err) {
+        console.error(`Error getting procedure definition: ${err}`);
+      }
+      return {
+        procedure_name: procedure.procedure_name,
+        procedure_type: procedure.procedure_type,
+        language: procedure.language || "sql",
+        parameter_list: procedure.parameter_list || "",
+        return_type: procedure.return_type !== "void" ? procedure.return_type : void 0,
+        definition: definition || void 0
+      };
+    } finally {
+      client.release();
+    }
+  }
+  async executeSQL(sql, options, parameters) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const statements = splitSQLStatements(sql, "postgres");
+      if (statements.length === 1) {
+        const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
+        let result;
+        if (parameters && parameters.length > 0) {
+          try {
+            result = await client.query(processedStatement, parameters);
+          } catch (error) {
+            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
+            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
+            console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
+            throw error;
+          }
+        } else {
+          result = await client.query(processedStatement);
+        }
+        return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
+      } else {
+        if (parameters && parameters.length > 0) {
+          throw new Error("Parameters are not supported for multi-statement queries in PostgreSQL");
+        }
+        let allRows = [];
+        let totalRowCount = 0;
+        await client.query("BEGIN");
+        try {
+          for (let statement of statements) {
+            const processedStatement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+            const result = await client.query(processedStatement);
+            if (result.rows && result.rows.length > 0) {
+              allRows.push(...result.rows);
+            }
+            if (result.rowCount) {
+              totalRowCount += result.rowCount;
+            }
+          }
+          await client.query("COMMIT");
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        }
+        return { rows: allRows, rowCount: totalRowCount };
+      }
+    } finally {
+      client.release();
+    }
+  }
+};
+var postgresConnector = new PostgresConnector();
+ConnectorRegistry.register(postgresConnector);
+export {
+  PostgresConnector
+};

package/dist/{registry-6VNMKD6G.js → registry-XSMMLRC4.js}

@@ -2,7 +2,8 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-LUNM7TUY.js";
+} from "./chunk-GRGEI5QT.js";
+import "./chunk-C7WEAPX4.js";
 export {
   ToolRegistry,
   getToolRegistry,