@xcr1234/dbhub-fork 1.0.0 → 1.1.0

package/dist/{chunk-6O5I6UAW.js → chunk-YYDWHEUE.js}

@@ -901,7 +901,7 @@ async function resolveSourceConfigs() {
       source.ssh_keepalive_count_max = sshResult.config.keepaliveCountMax;
     }
     if (dsnResult.isDemo) {
-      const { getSqliteInMemorySetupSql } = await import("./demo-loader-WKQAEFSX.js");
+      const { getSqliteInMemorySetupSql } = await import("./demo-loader-PSMTLZ2T.js");
       source.init_script = getSqliteInMemorySetupSql();
     }
     return {

package/dist/{demo-loader-WKQAEFSX.js → demo-loader-PSMTLZ2T.js}

@@ -1,5 +1,3 @@
-import "./chunk-FAIJPBT5.js";
-
 // src/config/demo-loader.ts
 import fs from "fs";
 import path from "path";

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   resolveSourceConfigs,
   resolveTomlConfigPath,
   resolveTransport
-} from "./chunk-6O5I6UAW.js";
+} from "./chunk-YYDWHEUE.js";
 import {
   loadConnectors
 } from "./chunk-WVVMH6FJ.js";
@@ -27,7 +27,6 @@ import {
   splitSQLStatements,
   stripCommentsAndStrings
 } from "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -1429,7 +1428,7 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-KI3KJMRY.js");
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-H3S7N4PP.js");
     initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -1571,12 +1570,12 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-CK6N5BXI.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-5RM44GWI.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-P6NXTMYE.js"), name: "SQLite", driver: "better-sqlite3" },
-  { load: () => import("./mysql-GOLPG2Q6.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-QHRMVK47.js"), name: "MariaDB", driver: "mariadb" },
-  { load: () => import("./oracle-3V2T7ZWF.js"), name: "Oracle", driver: "oracle" }
+  { load: () => import("./postgres-SN3BESYN.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-YV3KVJ3B.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-SJAXGYH3.js"), name: "SQLite", driver: "better-sqlite3" },
+  { load: () => import("./mysql-M4INQQ46.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-4IBCPIEV.js"), name: "MariaDB", driver: "mariadb" },
+  { load: () => import("./oracle-N4YKSM4F.js"), name: "Oracle", driver: "oracle" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);

package/dist/{mariadb-QHRMVK47.js → mariadb-4IBCPIEV.js}

@@ -14,7 +14,6 @@ import {
   obfuscateDSNPassword,
   splitSQLStatements
 } from "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 
 // src/connectors/mariadb/index.ts
 import * as mariadb from "mariadb";

package/dist/{mysql-GOLPG2Q6.js → mysql-M4INQQ46.js}

@@ -14,7 +14,6 @@ import {
   obfuscateDSNPassword,
   splitSQLStatements
 } from "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";

package/dist/oracle-N4YKSM4F.js

@@ -0,0 +1,384 @@
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements
+} from "./chunk-C7WEAPX4.js";
+
+// src/connectors/oracle/index.ts
+import oracledb from "oracledb";
+var OracleDSNParser = class {
+  async parse(dsn, config) {
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid Oracle DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      const serviceName = url.pathname ? url.pathname.substring(1) : "";
+      const port = url.port || "1521";
+      const connectString = `${url.hostname}:${port}/${serviceName}`;
+      const poolConfig = {
+        user: url.username,
+        password: url.password,
+        connectString,
+        // Optional tuning for connection pools
+        poolMin: 1,
+        poolMax: 10,
+        poolIncrement: 1
+      };
+      if (config?.connectionTimeoutSeconds !== void 0) {
+        poolConfig.poolTimeout = config.connectionTimeoutSeconds;
+      }
+      return poolConfig;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Oracle DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "oracle://scott:tiger@localhost:1521/ORCLCDB";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("oracle://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var OracleConnector = class _OracleConnector {
+  constructor() {
+    // Assuming "oracle" will be added to ConnectorType in interface.ts
+    this.id = "oracle";
+    this.name = "Oracle";
+    this.dsnParser = new OracleDSNParser();
+    this.pool = null;
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _OracleConnector();
+  }
+  async connect(dsn, initScript, config) {
+    try {
+      oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
+      const poolOptions = await this.dsnParser.parse(dsn, config);
+      this.pool = await oracledb.createPool(poolOptions);
+      if (config?.queryTimeoutSeconds !== void 0) {
+        this.queryTimeoutMs = config.queryTimeoutSeconds * 1e3;
+      }
+      const conn = await this.pool.getConnection();
+      try {
+        await conn.execute("SELECT 1 FROM DUAL");
+        if (initScript) {
+          await conn.execute(initScript);
+        }
+      } finally {
+        await conn.close();
+      }
+    } catch (err) {
+      console.error("Failed to connect to Oracle database:", err);
+      throw err;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.close(0);
+      this.pool = null;
+    }
+  }
+  async getSchemas() {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const result = await conn.execute(`
+        SELECT USERNAME
+        FROM ALL_USERS
+        WHERE ORACLE_MAINTAINED = 'N'
+        ORDER BY USERNAME
+      `);
+      return result.rows.map((row) => row.USERNAME);
+    } catch (error) {
+      console.error("Error getting schemas:", error);
+      throw error;
+    } finally {
+      await conn.close();
+    }
+  }
+  async getTables(schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const result = await conn.execute(
+        `
+        SELECT TABLE_NAME 
+        FROM ALL_TABLES 
+        WHERE OWNER = :schema
+        ORDER BY TABLE_NAME
+        `,
+        { schema: targetSchema }
+      );
+      return result.rows.map((row) => row.TABLE_NAME);
+    } finally {
+      await conn.close();
+    }
+  }
+  async tableExists(tableName, schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const result = await conn.execute(
+        `
+        SELECT COUNT(*) AS CNT
+        FROM ALL_TABLES 
+        WHERE OWNER = :schema 
+        AND TABLE_NAME = :tableName
+        `,
+        { schema: targetSchema, tableName: tableName.toUpperCase() }
+      );
+      return result.rows[0].CNT > 0;
+    } finally {
+      await conn.close();
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const result = await conn.execute(
+        `
+        SELECT 
+          i.INDEX_NAME, 
+          ic.COLUMN_NAME, 
+          i.UNIQUENESS,
+          c.CONSTRAINT_TYPE
+        FROM ALL_INDEXES i
+        JOIN ALL_IND_COLUMNS ic 
+          ON i.INDEX_NAME = ic.INDEX_NAME AND i.OWNER = ic.INDEX_OWNER
+        LEFT JOIN ALL_CONSTRAINTS c 
+          ON c.INDEX_NAME = i.INDEX_NAME AND c.OWNER = i.OWNER AND c.CONSTRAINT_TYPE = 'P'
+        WHERE i.TABLE_OWNER = :schema 
+          AND i.TABLE_NAME = :tableName
+        ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION
+        `,
+        { schema: targetSchema, tableName: tableName.toUpperCase() }
+      );
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of result.rows) {
+        const indexName = row.INDEX_NAME;
+        const columnName = row.COLUMN_NAME;
+        const isUnique = row.UNIQUENESS === "UNIQUE";
+        const isPrimary = row.CONSTRAINT_TYPE === "P";
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        indexMap.get(indexName).columns.push(columnName);
+      }
+      return Array.from(indexMap.entries()).map(([indexName, indexInfo]) => ({
+        index_name: indexName,
+        column_names: indexInfo.columns,
+        is_unique: indexInfo.is_unique,
+        is_primary: indexInfo.is_primary
+      }));
+    } finally {
+      await conn.close();
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const result = await conn.execute(
+        `
+        SELECT 
+          c.COLUMN_NAME as "column_name",
+          c.DATA_TYPE as "data_type",
+          c.NULLABLE as "is_nullable",
+          c.DATA_DEFAULT as "column_default",
+          cc.COMMENTS as "description"
+        FROM ALL_TAB_COLS c
+        LEFT JOIN ALL_COL_COMMENTS cc 
+          ON c.OWNER = cc.OWNER AND c.TABLE_NAME = cc.TABLE_NAME AND c.COLUMN_NAME = cc.COLUMN_NAME
+        WHERE c.OWNER = :schema
+          AND c.TABLE_NAME = :tableName
+          AND c.USER_GENERATED = 'YES' -- Exclude hidden/system columns
+        ORDER BY c.COLUMN_ID
+        `,
+        { schema: targetSchema, tableName: tableName.toUpperCase() }
+      );
+      return result.rows.map((row) => ({
+        ...row,
+        // Oracle returns 'Y' or 'N' for NULLABLE; map it to standard format if needed, or leave as string
+        is_nullable: row.is_nullable === "Y" ? "YES" : "NO",
+        description: row.description || null
+      }));
+    } finally {
+      await conn.close();
+    }
+  }
+  async getTableComment(tableName, schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const result = await conn.execute(
+        `
+        SELECT COMMENTS
+        FROM ALL_TAB_COMMENTS
+        WHERE OWNER = :schema
+        AND TABLE_NAME = :tableName
+        `,
+        { schema: targetSchema, tableName: tableName.toUpperCase() }
+      );
+      const rows = result.rows;
+      return rows.length > 0 ? rows[0].COMMENTS || null : null;
+    } finally {
+      await conn.close();
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      let typeFilter = "OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')";
+      if (routineType === "function") typeFilter = "OBJECT_TYPE = 'FUNCTION'";
+      if (routineType === "procedure") typeFilter = "OBJECT_TYPE = 'PROCEDURE'";
+      const result = await conn.execute(
+        `
+        SELECT OBJECT_NAME
+        FROM ALL_OBJECTS
+        WHERE OWNER = :schema
+        AND ${typeFilter}
+        ORDER BY OBJECT_NAME
+        `,
+        { schema: targetSchema }
+      );
+      return result.rows.map((row) => row.OBJECT_NAME);
+    } finally {
+      await conn.close();
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const targetSchema = schema ? schema.toUpperCase() : await this.getCurrentSchema(conn);
+      const targetProcedure = procedureName.toUpperCase();
+      const objResult = await conn.execute(
+        `SELECT OBJECT_TYPE FROM ALL_OBJECTS WHERE OWNER = :schema AND OBJECT_NAME = :procName AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')`,
+        { schema: targetSchema, procName: targetProcedure }
+      );
+      const objRows = objResult.rows;
+      if (objRows.length === 0) {
+        throw new Error(`Stored procedure '${procedureName}' not found in ${targetSchema}`);
+      }
+      const procType = objRows[0].OBJECT_TYPE.toLowerCase();
+      const argResult = await conn.execute(
+        `
+        SELECT ARGUMENT_NAME, IN_OUT, DATA_TYPE 
+        FROM ALL_ARGUMENTS 
+        WHERE OWNER = :schema 
+          AND OBJECT_NAME = :procName
+          AND ARGUMENT_NAME IS NOT NULL
+        ORDER BY POSITION
+        `,
+        { schema: targetSchema, procName: targetProcedure }
+      );
+      const parameters = argResult.rows.map((p) => `${p.ARGUMENT_NAME} ${p.IN_OUT} ${p.DATA_TYPE}`).join(", ");
+      let definition = "";
+      try {
+        const srcResult = await conn.execute(
+          `
+          SELECT TEXT 
+          FROM ALL_SOURCE 
+          WHERE OWNER = :schema AND NAME = :procName 
+          ORDER BY LINE
+          `,
+          { schema: targetSchema, procName: targetProcedure }
+        );
+        definition = srcResult.rows.map((r) => r.TEXT).join("");
+      } catch (err) {
+        console.error(`Error fetching source for ${targetProcedure}: ${err}`);
+      }
+      return {
+        procedure_name: targetProcedure,
+        procedure_type: procType,
+        language: "plsql",
+        parameter_list: parameters,
+        definition: definition || void 0
+      };
+    } finally {
+      await conn.close();
+    }
+  }
+  async getCurrentSchema(conn) {
+    const result = await conn.execute(`SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') as SCHEMA FROM DUAL`);
+    return result.rows[0].SCHEMA;
+  }
+  async executeSQL(sql, options, parameters) {
+    if (!this.pool) throw new Error("Not connected to database");
+    const conn = await this.pool.getConnection();
+    try {
+      const execOptions = {
+        outFormat: oracledb.OUT_FORMAT_OBJECT,
+        autoCommit: true
+        // Default true for executing read/write commands
+      };
+      if (this.queryTimeoutMs) {
+        execOptions.timeout = this.queryTimeoutMs;
+      }
+      let processedSQL = sql;
+      if (options.maxRows) {
+        const statements = splitSQLStatements(sql, "oracle");
+        const processedStatements = statements.map((statement) => {
+          if (statement.trim().toUpperCase().startsWith("SELECT") && !statement.toUpperCase().includes("FETCH FIRST")) {
+            return `${statement} FETCH FIRST ${options.maxRows} ROWS ONLY`;
+          }
+          return SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+        });
+        processedSQL = processedStatements.join(";\n");
+        if (processedStatements.length > 1) {
+          processedSQL = `BEGIN
+${processedSQL};
+END;`;
+        }
+      }
+      const result = await conn.execute(processedSQL, parameters || [], execOptions);
+      return {
+        rows: result.rows || [],
+        rowCount: result.rowsAffected || 0
+      };
+    } catch (error) {
+      console.error("Error executing query:", error);
+      throw error;
+    } finally {
+      await conn.close();
+    }
+  }
+};
+var oracleConnector = new OracleConnector();
+ConnectorRegistry.register(oracleConnector);
+export {
+  OracleConnector
+};

package/dist/{postgres-CK6N5BXI.js → postgres-SN3BESYN.js}

@@ -10,7 +10,6 @@ import {
   obfuscateDSNPassword,
   splitSQLStatements
 } from "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 
 // src/connectors/postgres/index.ts
 import fs from "fs";

package/dist/{registry-KI3KJMRY.js → registry-H3S7N4PP.js}

@@ -2,10 +2,9 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-6O5I6UAW.js";
+} from "./chunk-YYDWHEUE.js";
 import "./chunk-WVVMH6FJ.js";
 import "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 export {
   ToolRegistry,
   getToolRegistry,