@xcr1234/dbhub-fork 1.0.0

package/dist/postgres-CK6N5BXI.js

@@ -0,0 +1,520 @@
+import {
+  quoteIdentifier
+} from "./chunk-JFWX35TB.js";
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements
+} from "./chunk-C7WEAPX4.js";
+import "./chunk-FAIJPBT5.js";
+
+// src/connectors/postgres/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import pg from "pg";
+
+// src/connectors/postgres/failed-to-read-certificate.ts
+var FailedToReadCertificate = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FailedToReadCertificate";
+  }
+};
+
+// src/connectors/postgres/index.ts
+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
+      };
+      let sslmode;
+      let sslrootcert;
+      url.forEachSearchParam((value, key) => {
+        if (key === "sslmode") {
+          sslmode = value;
+        } else if (key === "sslrootcert") {
+          sslrootcert = value;
+        }
+      });
+      if (sslmode === "disable") {
+        poolConfig.ssl = false;
+      } else if (sslmode === "require") {
+        poolConfig.ssl = { rejectUnauthorized: false };
+      } else if (sslmode === "verify-ca" || sslmode === "verify-full") {
+        const sslConfig = { rejectUnauthorized: true };
+        if (sslmode === "verify-ca") {
+          sslConfig.checkServerIdentity = () => void 0;
+        }
+        if (sslrootcert) {
+          const certPath = sslrootcert.startsWith("~/") ? path.join(os.homedir(), sslrootcert.slice(2)) : sslrootcert;
+          try {
+            sslConfig.ca = await fs.promises.readFile(certPath, "utf-8");
+          } catch (err) {
+            throw new FailedToReadCertificate(
+              `Failed to read SSL root certificate at '${certPath}': ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        poolConfig.ssl = sslConfig;
+      } else if (sslmode !== void 0) {
+        poolConfig.ssl = true;
+      }
+      if (connectionTimeoutSeconds !== void 0) {
+        poolConfig.connectionTimeoutMillis = connectionTimeoutSeconds * 1e3;
+      }
+      if (queryTimeoutSeconds !== void 0) {
+        poolConfig.query_timeout = queryTimeoutSeconds * 1e3;
+      }
+      return poolConfig;
+    } catch (error) {
+      if (error instanceof FailedToReadCertificate) {
+        throw error;
+      }
+      const originalError = error instanceof Error ? error : new Error(String(error));
+      throw new Error(
+        `Failed to parse PostgreSQL DSN: ${originalError.message}`,
+        { cause: originalError }
+      );
+    }
+  }
+  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','v')
+      `,
+        [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
+};