orcaq 1.0.32 → 1.1.1

package/.output/server/chunks/_/db-connection.mjs

@@ -1,59 +1,180 @@
 import { e as createSshTunnel } from '../nitro/nitro.mjs';
 import knex from 'knex';
+import * as oracledb from 'oracledb';
 import pg from 'pg';
+import { accessSync, constants } from 'node:fs';
+import { Readable } from 'node:stream';
 
 var DatabaseClientType = /* @__PURE__ */ ((DatabaseClientType2) => {
   DatabaseClientType2["POSTGRES"] = "postgres";
   DatabaseClientType2["MYSQL"] = "mysql";
+  DatabaseClientType2["MARIADB"] = "mariadb";
   DatabaseClientType2["MYSQL2"] = "mysql2";
+  DatabaseClientType2["MONGODB"] = "mongodb";
+  DatabaseClientType2["REDIS"] = "redis";
   DatabaseClientType2["SQLITE3"] = "sqlite3";
+  DatabaseClientType2["SNOWFLAKE"] = "snowflake";
   DatabaseClientType2["BETTER_SQLITE3"] = "better-sqlite3";
   DatabaseClientType2["MSSQL"] = "mssql";
   DatabaseClientType2["ORACLE"] = "oracledb";
   return DatabaseClientType2;
 })(DatabaseClientType || {});
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-const MYSQL_PLACEHOLDER_MESSAGE = "MySQL adapter is a placeholder and not implemented yet.";
-class MysqlAdapter {
-  constructor(connection) {
-    __publicField$1(this, "knex");
-    __publicField$1(this, "dbType", DatabaseClientType.MYSQL);
-    __publicField$1(this, "connection");
-    this.connection = connection;
-    this.knex = {};
-  }
-  async rawQuery(_sql, _bindings = []) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
-  }
-  async rawOut(_sql, _bindings = []) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
-  }
-  streamQuery(_sql, _bindings = [], _options = {}) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
-  }
-  async acquireRawConnection() {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
-  }
-  async releaseRawConnection(_connection) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
-  }
-  async healthCheck() {
-    return false;
+const DEFAULT_RENDER_LIMIT = 100;
+const MAX_RENDER_LIMIT = 500;
+const MAX_EXPORT_LIMIT = 1e5;
+const SELECT_PATTERN = /^(select|with|values|table)\b/i;
+const MUTATION_PATTERN = /^(insert|update|delete|drop|truncate|alter|create|grant|revoke|comment|refresh|vacuum)\b/i;
+const POSTGRES_OID_TYPE_MAP = {
+  16: "bool",
+  20: "int8",
+  21: "int2",
+  23: "int4",
+  25: "text",
+  114: "json",
+  700: "float4",
+  701: "float8",
+  1043: "varchar",
+  1082: "date",
+  1114: "timestamp",
+  1184: "timestamptz",
+  1700: "numeric",
+  2950: "uuid",
+  3802: "jsonb"
+};
+function stripSqlComments(sql) {
+  return sql.replace(/\/\*[\s\S]*?\*\//g, "").replace(/--.*$/gm, "");
+}
+function replaceSqlComments(sql, replacer) {
+  let index = 0;
+  let nextSql = "";
+  while (index < sql.length) {
+    const current = sql[index];
+    const next = sql[index + 1];
+    if (current === "'") {
+      nextSql += current;
+      index += 1;
+      while (index < sql.length) {
+        const quotedChar = sql[index];
+        nextSql += quotedChar;
+        if (quotedChar === "'" && sql[index + 1] === "'") {
+          nextSql += sql[index + 1];
+          index += 2;
+          continue;
+        }
+        index += 1;
+        if (quotedChar === "'") {
+          break;
+        }
+      }
+      continue;
+    }
+    if (current === '"') {
+      nextSql += current;
+      index += 1;
+      while (index < sql.length) {
+        const quotedChar = sql[index];
+        nextSql += quotedChar;
+        if (quotedChar === '"' && sql[index + 1] === '"') {
+          nextSql += sql[index + 1];
+          index += 2;
+          continue;
+        }
+        index += 1;
+        if (quotedChar === '"') {
+          break;
+        }
+      }
+      continue;
+    }
+    if (current === "-" && next === "-") {
+      const start = index;
+      index += 2;
+      while (index < sql.length && sql[index] !== "\n") {
+        index += 1;
+      }
+      nextSql += replacer(sql.slice(start, index));
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      const start = index;
+      index += 2;
+      while (index < sql.length) {
+        if (sql[index] === "*" && sql[index + 1] === "/") {
+          index += 2;
+          break;
+        }
+        index += 1;
+      }
+      nextSql += replacer(sql.slice(start, index));
+      continue;
+    }
+    nextSql += current;
+    index += 1;
   }
-  getNativeSql(sql, _bindings) {
-    throw new Error(`${MYSQL_PLACEHOLDER_MESSAGE} SQL: ${sql}`);
+  return nextSql;
+}
+const COMMENT_NAMED_BIND_PATTERN = /(^|[^A-Za-z0-9_:]):([A-Za-z_][A-Za-z0-9_]*)/g;
+function maskNamedBindParametersInComments(sql) {
+  return replaceSqlComments(
+    sql,
+    (comment) => comment.replace(
+      COMMENT_NAMED_BIND_PATTERN,
+      (_, prefix, name) => `${prefix}__heraq_comment_bind_${name}__`
+    )
+  );
+}
+function stripMarkdownCodeFence(sql) {
+  var _a;
+  const trimmed = sql.trim();
+  const match = trimmed.match(/^```(?:sql)?\s*([\s\S]*?)```$/i);
+  return ((_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.trim()) || trimmed;
+}
+function normalizeSql(sql) {
+  return stripSqlComments(stripMarkdownCodeFence(sql)).trim().replace(/;+\s*$/, "");
+}
+function isSelectLikeSql(sql) {
+  return SELECT_PATTERN.test(normalizeSql(sql));
+}
+function isMutationSql(sql) {
+  return MUTATION_PATTERN.test(normalizeSql(sql));
+}
+function clampLimit(limit) {
+  if (!limit || Number.isNaN(limit)) {
+    return DEFAULT_RENDER_LIMIT;
   }
-  async destroy() {
-    return;
+  return Math.max(1, Math.min(limit, MAX_RENDER_LIMIT));
+}
+function quoteIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
   }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function getQualifiedTableName(schemaName, tableName) {
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(tableName)}`;
+}
+function resolveFieldType(field) {
+  const oid = Number(field.dataTypeID);
+  return POSTGRES_OID_TYPE_MAP[oid] || String(field.dataTypeID || "unknown");
 }
 
+var EConnectionMethod = /* @__PURE__ */ ((EConnectionMethod2) => {
+  EConnectionMethod2["STRING"] = "string";
+  EConnectionMethod2["FORM"] = "form";
+  EConnectionMethod2["FILE"] = "file";
+  return EConnectionMethod2;
+})(EConnectionMethod || {});
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const normalizeBindableSql = (sql, bindings) => {
+  if (!bindings || Array.isArray(bindings) || typeof bindings !== "object") {
+    return sql;
+  }
+  return maskNamedBindParametersInComments(sql);
+};
 class BaseDatabaseAdapter {
   constructor(dbType, connection, knexInstance) {
     __publicField(this, "knex");
@@ -64,10 +185,13 @@ class BaseDatabaseAdapter {
     this.knex = knexInstance;
   }
   async rawQuery(sql, bindings = []) {
-    return this._rawQuery(sql, bindings);
+    return this._rawQuery(
+      normalizeBindableSql(sql, bindings),
+      bindings
+    );
   }
   async rawOut(sql, bindings = []) {
-    return this._rawOut(sql, bindings);
+    return this._rawOut(normalizeBindableSql(sql, bindings), bindings);
   }
   streamQuery(sql, bindings = [], options = {}) {
     return this._streamQuery(sql, bindings, options);
@@ -79,7 +203,7 @@ class BaseDatabaseAdapter {
     await this.knex.client.releaseConnection(connection);
   }
   getNativeSql(sql, bindings) {
-    return this._getNativeSql(sql, bindings);
+    return this._getNativeSql(normalizeBindableSql(sql, bindings), bindings);
   }
   async healthCheck() {
     try {
@@ -98,6 +222,240 @@ class BaseDatabaseAdapter {
   }
 }
 
+function normalizeMysqlFields(fields = []) {
+  return fields.map((field, index) => {
+    var _a, _b;
+    return {
+      name: field.name,
+      tableID: 0,
+      columnID: index,
+      dataTypeID: (_a = field.columnType) != null ? _a : 0,
+      dataTypeSize: (_b = field.columnLength) != null ? _b : 0,
+      dataTypeModifier: 0,
+      format: "text"
+    };
+  });
+}
+function inferMysqlCommand(sql) {
+  var _a;
+  return ((_a = sql.trim().split(/\s+/, 1)[0]) == null ? void 0 : _a.toUpperCase()) || "";
+}
+class MysqlAdapter extends BaseDatabaseAdapter {
+  constructor(connection, dbType = DatabaseClientType.MYSQL) {
+    const knexInstance = knex({
+      client: DatabaseClientType.MYSQL2,
+      connection,
+      pool: {
+        min: 1,
+        max: 10,
+        idleTimeoutMillis: 5 * 60 * 1e3
+      },
+      log: {
+        warn(message) {
+          console.warn("[MysqlAdapter]", message);
+        },
+        error(message) {
+          console.error("[MysqlAdapter]", message);
+        },
+        deprecate(message) {
+          console.warn("[MysqlAdapter] Deprecation:", message);
+        },
+        debug(message) {
+          console.debug("[MysqlAdapter]", message);
+        }
+      }
+    });
+    super(dbType, connection, knexInstance);
+  }
+  async queryWithMetadata(sql, bindings = [], rowsAsArray = false) {
+    const connection = await this.acquireRawConnection();
+    try {
+      return await new Promise((resolve, reject) => {
+        connection.query(
+          {
+            sql,
+            values: bindings,
+            rowsAsArray
+          },
+          (error, rows, fields) => {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve({
+              rows,
+              fields: fields != null ? fields : []
+            });
+          }
+        );
+      });
+    } finally {
+      await this.releaseRawConnection(connection);
+    }
+  }
+  async _rawQuery(sql, bindings = []) {
+    const { rows } = await this.queryWithMetadata(sql, bindings);
+    return Array.isArray(rows) ? rows : [];
+  }
+  async _rawOut(sql, bindings = []) {
+    const { rows, fields } = await this.queryWithMetadata(
+      sql,
+      bindings,
+      true
+    );
+    if (Array.isArray(rows)) {
+      return {
+        rows,
+        fields: normalizeMysqlFields(fields),
+        rowCount: rows.length,
+        command: inferMysqlCommand(sql)
+      };
+    }
+    return {
+      rows: [],
+      fields: normalizeMysqlFields(fields),
+      rowCount: rows.affectedRows,
+      command: inferMysqlCommand(sql)
+    };
+  }
+  _streamQuery(sql, bindings = [], options = {}) {
+    return this.knex.raw(sql, bindings).stream(options);
+  }
+  _getNativeSql(sql, bindings) {
+    return this.knex.raw(sql, bindings).toSQL().toNative();
+  }
+}
+
+const DEFAULT_ORACLE_PORT = 1521;
+function buildOracleConnectString(host, port, serviceName) {
+  return `${host}:${port}/${serviceName}`;
+}
+function normalizeOracleConnection(connection) {
+  var _a;
+  if (typeof connection === "string") {
+    const url = new URL(connection);
+    const serviceName2 = decodeURIComponent(url.pathname.replace(/^\/+/, ""));
+    return {
+      user: decodeURIComponent(url.username),
+      password: decodeURIComponent(url.password),
+      connectString: buildOracleConnectString(
+        url.hostname,
+        Number(url.port) || DEFAULT_ORACLE_PORT,
+        serviceName2
+      )
+    };
+  }
+  const candidate = connection || {};
+  const host = candidate.host || "127.0.0.1";
+  const port = Number(candidate.port) || DEFAULT_ORACLE_PORT;
+  const serviceName = candidate.serviceName || candidate.database;
+  if (!serviceName && !candidate.connectString) {
+    throw new Error(
+      "Oracle connections require a service name or connectString."
+    );
+  }
+  return {
+    user: (_a = candidate.user) != null ? _a : candidate.username,
+    password: candidate.password,
+    connectString: candidate.connectString || buildOracleConnectString(host, port, serviceName),
+    ...candidate.ssl ? { ssl: candidate.ssl } : {}
+  };
+}
+function normalizeOracleFields(fields = []) {
+  return fields.map((field, index) => {
+    var _a, _b, _c;
+    return {
+      name: field.name || `column_${index + 1}`,
+      tableID: 0,
+      columnID: index,
+      dataTypeID: (_b = (_a = field.dbType) != null ? _a : field.fetchType) != null ? _b : 0,
+      dataTypeSize: (_c = field.byteSize) != null ? _c : 0,
+      dataTypeModifier: 0,
+      format: "text"
+    };
+  });
+}
+function inferOracleCommand(sql) {
+  var _a;
+  return ((_a = sql.trim().split(/\s+/, 1)[0]) == null ? void 0 : _a.toUpperCase()) || "";
+}
+class OracleAdapter extends BaseDatabaseAdapter {
+  constructor(connection) {
+    const normalizedConnection = normalizeOracleConnection(connection);
+    const knexInstance = knex({
+      client: DatabaseClientType.ORACLE,
+      connection: normalizedConnection,
+      pool: {
+        min: 1,
+        max: 10,
+        idleTimeoutMillis: 5 * 60 * 1e3
+      },
+      log: {
+        warn(message) {
+          console.warn("[OracleAdapter]", message);
+        },
+        error(message) {
+          console.error("[OracleAdapter]", message);
+        },
+        deprecate(message) {
+          console.warn("[OracleAdapter] Deprecation:", message);
+        },
+        debug(message) {
+          console.debug("[OracleAdapter]", message);
+        }
+      }
+    });
+    super(DatabaseClientType.ORACLE, normalizedConnection, knexInstance);
+  }
+  async execute(sql, bindings = [], outFormat = oracledb.OUT_FORMAT_OBJECT) {
+    const connection = await this.acquireRawConnection();
+    try {
+      return await connection.execute(sql, bindings, {
+        outFormat
+      });
+    } finally {
+      await this.releaseRawConnection(connection);
+    }
+  }
+  async healthCheck() {
+    try {
+      await this.knex.raw("SELECT 1 FROM DUAL");
+      return true;
+    } catch (error) {
+      console.error("[OracleAdapter] Health check failed", error);
+      return false;
+    }
+  }
+  async _rawQuery(sql, bindings = []) {
+    const result = await this.execute(
+      sql,
+      bindings,
+      oracledb.OUT_FORMAT_OBJECT
+    );
+    return result.rows || [];
+  }
+  async _rawOut(sql, bindings = []) {
+    var _a, _b, _c;
+    const result = await this.execute(
+      sql,
+      bindings,
+      oracledb.OUT_FORMAT_ARRAY
+    );
+    return {
+      rows: result.rows || [],
+      fields: normalizeOracleFields(result.metaData),
+      rowCount: (_c = (_b = result.rowsAffected) != null ? _b : (_a = result.rows) == null ? void 0 : _a.length) != null ? _c : 0,
+      command: inferOracleCommand(sql)
+    };
+  }
+  _streamQuery(sql, bindings = [], options = {}) {
+    return this.knex.raw(sql, bindings).stream(options);
+  }
+  _getNativeSql(sql, bindings) {
+    return this.knex.raw(sql, bindings).toSQL().toNative();
+  }
+}
+
 const RAW = (val) => val;
 const TEMPORAL_OIDS = [
   1082,
@@ -190,12 +548,188 @@ class PostgresAdapter extends BaseDatabaseAdapter {
   }
 }
 
+function assertReadableSqliteFile(filename) {
+  if (filename === ":memory:") {
+    return;
+  }
+  try {
+    accessSync(filename, constants.F_OK);
+  } catch {
+    throw new Error(`SQLite database file was not found: ${filename}`);
+  }
+  try {
+    accessSync(filename, constants.R_OK);
+  } catch {
+    throw new Error(`SQLite database file is not readable: ${filename}`);
+  }
+}
+function normalizeSqliteFilename(fileName) {
+  const normalizedPath = decodeURIComponent(fileName).replace(/\\/g, "/");
+  if (/^\/[A-Za-z]:\//.test(normalizedPath)) {
+    return normalizedPath.slice(1);
+  }
+  return normalizedPath;
+}
+function normalizeSqliteConnection(connection) {
+  if (typeof connection === "string") {
+    if (connection.startsWith("sqlite3://")) {
+      const url = new URL(connection);
+      const filename2 = normalizeSqliteFilename(url.pathname);
+      assertReadableSqliteFile(filename2);
+      return {
+        filename: filename2
+      };
+    }
+    const filename = normalizeSqliteFilename(connection);
+    assertReadableSqliteFile(filename);
+    return {
+      filename
+    };
+  }
+  const candidate = connection || {};
+  if (candidate.filename) {
+    const filename = normalizeSqliteFilename(candidate.filename);
+    assertReadableSqliteFile(filename);
+    return {
+      filename
+    };
+  }
+  if (candidate.filePath) {
+    const filename = normalizeSqliteFilename(candidate.filePath);
+    assertReadableSqliteFile(filename);
+    return {
+      filename
+    };
+  }
+  throw new Error("SQLite connections require a filename.");
+}
+function createSyntheticFields(row) {
+  return Object.keys(row || {}).map((name, index) => ({
+    name,
+    tableID: 0,
+    columnID: index,
+    dataTypeID: 0,
+    dataTypeSize: 0,
+    dataTypeModifier: 0,
+    format: "text"
+  }));
+}
+function inferSqliteCommand(sql) {
+  var _a;
+  return ((_a = sql.trim().split(/\s+/, 1)[0]) == null ? void 0 : _a.toUpperCase()) || "";
+}
+class SqliteAdapter extends BaseDatabaseAdapter {
+  constructor(connection) {
+    const normalizedConnection = normalizeSqliteConnection(connection);
+    const knexInstance = knex({
+      client: DatabaseClientType.SQLITE3,
+      connection: normalizedConnection,
+      useNullAsDefault: true,
+      pool: {
+        min: 1,
+        max: 1,
+        idleTimeoutMillis: 5 * 60 * 1e3
+      },
+      log: {
+        warn(message) {
+          console.warn("[SqliteAdapter]", message);
+        },
+        error(message) {
+          console.error("[SqliteAdapter]", message);
+        },
+        deprecate(message) {
+          console.warn("[SqliteAdapter] Deprecation:", message);
+        },
+        debug(message) {
+          console.debug("[SqliteAdapter]", message);
+        }
+      }
+    });
+    super(DatabaseClientType.SQLITE3, normalizedConnection, knexInstance);
+  }
+  async all(sql, bindings = []) {
+    const connection = await this.acquireRawConnection();
+    try {
+      return await new Promise((resolve, reject) => {
+        connection.all(sql, bindings, (error, rows) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(rows || []);
+        });
+      });
+    } finally {
+      await this.releaseRawConnection(connection);
+    }
+  }
+  async run(sql, bindings = []) {
+    const connection = await this.acquireRawConnection();
+    try {
+      return await new Promise((resolve, reject) => {
+        connection.run(
+          sql,
+          bindings,
+          function(error) {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve(this);
+          }
+        );
+      });
+    } finally {
+      await this.releaseRawConnection(connection);
+    }
+  }
+  async _rawQuery(sql, bindings = []) {
+    return this.all(sql, bindings);
+  }
+  async _rawOut(sql, bindings = []) {
+    const trimmedQuery = sql.trim().toUpperCase();
+    const isSelectLike = trimmedQuery.startsWith("SELECT") || trimmedQuery.startsWith("WITH") || trimmedQuery.startsWith("PRAGMA") || trimmedQuery.startsWith("EXPLAIN");
+    if (isSelectLike) {
+      const namedRows = await this.all(sql, bindings);
+      const fields = createSyntheticFields(namedRows[0]);
+      const rows = namedRows.map((row) => fields.map((f) => row[f.name]));
+      return {
+        rows,
+        fields,
+        rowCount: rows.length,
+        command: inferSqliteCommand(sql)
+      };
+    }
+    const result = await this.run(sql, bindings);
+    return {
+      rows: [],
+      fields: [],
+      rowCount: result.changes || 0,
+      command: inferSqliteCommand(sql)
+    };
+  }
+  _streamQuery(sql, bindings = [], _options = {}) {
+    const adapter = this;
+    return Readable.from(
+      async function* () {
+        const rows = await adapter.all(sql, bindings);
+        for (const row of rows) {
+          yield row;
+        }
+      }()
+    );
+  }
+  _getNativeSql(sql, bindings) {
+    return this.knex.raw(sql, bindings).toSQL().toNative();
+  }
+}
+
 const ADAPTER_FACTORIES = {
   [DatabaseClientType.POSTGRES]: (connection) => new PostgresAdapter(connection),
   [DatabaseClientType.MYSQL]: (connection) => new MysqlAdapter(connection),
-  [DatabaseClientType.SQLITE3]: () => {
-    throw new Error("Database type 'sqlite3' is not supported yet.");
-  }
+  [DatabaseClientType.MARIADB]: (connection) => new MysqlAdapter(connection, DatabaseClientType.MARIADB),
+  [DatabaseClientType.ORACLE]: (connection) => new OracleAdapter(connection),
+  [DatabaseClientType.SQLITE3]: (connection) => new SqliteAdapter(connection)
 };
 function createDatabaseAdapter(type, connection) {
   const factory = ADAPTER_FACTORIES[type];
@@ -207,6 +741,19 @@ function createDatabaseAdapter(type, connection) {
 
 const adapterCache = /* @__PURE__ */ new Map();
 const LRU_TIMEOUT = 5 * 60 * 1e3;
+const DEFAULT_PORTS = {
+  [DatabaseClientType.POSTGRES]: 5432,
+  [DatabaseClientType.MYSQL]: 3306,
+  [DatabaseClientType.MARIADB]: 3306,
+  [DatabaseClientType.MYSQL2]: 3306,
+  [DatabaseClientType.MONGODB]: 27017,
+  [DatabaseClientType.REDIS]: 6379,
+  [DatabaseClientType.MSSQL]: 1433,
+  [DatabaseClientType.ORACLE]: 1521,
+  [DatabaseClientType.SNOWFLAKE]: 443,
+  [DatabaseClientType.BETTER_SQLITE3]: 0,
+  [DatabaseClientType.SQLITE3]: 0
+};
 function cleanupIdleAdapters() {
   const now = Date.now();
   for (const [key, cached] of adapterCache.entries()) {
@@ -255,6 +802,84 @@ process.on("SIGTERM", async () => {
 process.on("exit", async () => {
   await shutdownAllAdapters();
 });
+function getDefaultPort(type) {
+  var _a;
+  return (_a = DEFAULT_PORTS[type]) != null ? _a : 5432;
+}
+async function resolveHealthCheckConnection({
+  url,
+  type,
+  method,
+  host,
+  port,
+  username,
+  password,
+  database,
+  serviceName,
+  filePath,
+  ssl,
+  ssh
+}) {
+  var _a;
+  let sshTunnelClose;
+  if (method === EConnectionMethod.STRING) {
+    if (!url) {
+      throw new Error(
+        "Missing connection string for string-based health check."
+      );
+    }
+    return {
+      connection: url,
+      sshTunnelClose
+    };
+  }
+  if (method === EConnectionMethod.FILE) {
+    if (!filePath) {
+      throw new Error("Missing file path for file-based health check.");
+    }
+    return {
+      connection: {
+        filename: filePath
+      },
+      sshTunnelClose
+    };
+  }
+  if (!host) {
+    throw new Error("Missing host for form-based health check.");
+  }
+  let finalHost = host;
+  let finalPort = parseInt(port || `${getDefaultPort(type)}`, 10);
+  if (ssh == null ? void 0 : ssh.enabled) {
+    const tunnel = await createSshTunnel(ssh, host, finalPort);
+    finalHost = tunnel.localHost;
+    finalPort = tunnel.localPort;
+    sshTunnelClose = tunnel.close;
+  }
+  const connection = {
+    host: finalHost,
+    port: finalPort,
+    user: username,
+    password
+  };
+  if (serviceName) {
+    connection.database = serviceName;
+    connection.serviceName = serviceName;
+  } else if (database) {
+    connection.database = database;
+  }
+  if ((ssl == null ? void 0 : ssl.mode) && ssl.mode !== "disable") {
+    connection.ssl = {
+      rejectUnauthorized: (_a = ssl.rejectUnauthorized) != null ? _a : true,
+      ca: ssl.ca,
+      cert: ssl.cert,
+      key: ssl.key
+    };
+  }
+  return {
+    connection,
+    sshTunnelClose
+  };
+}
 const getDatabaseSource = async ({
   dbConnectionString,
   type,
@@ -263,6 +888,8 @@ const getDatabaseSource = async ({
   username,
   password,
   database,
+  serviceName,
+  filePath,
   ssl,
   ssh
 }) => {
@@ -271,22 +898,38 @@ const getDatabaseSource = async ({
   let finalConnection = dbConnectionString;
   let cacheKey = `${dbType}://${dbConnectionString}`;
   let sshTunnelClose;
-  if (!dbConnectionString && host) {
+  const targetName = serviceName || database || "";
+  if (!dbConnectionString && filePath) {
+    finalConnection = {
+      filename: filePath
+    };
+    cacheKey = `${dbType}://${filePath}`;
+  } else if (!dbConnectionString && host) {
     let finalHost = host;
-    let finalPort = parseInt(port || "5432", 10);
+    let finalPort = parseInt(port || `${getDefaultPort(dbType)}`, 10);
     if (ssh == null ? void 0 : ssh.enabled) {
       const tunnel = await createSshTunnel(ssh, host, finalPort);
       finalHost = tunnel.localHost;
       finalPort = tunnel.localPort;
       sshTunnelClose = tunnel.close;
     }
-    finalConnection = {
-      host: finalHost,
-      port: finalPort,
-      user: username,
-      password,
-      database
-    };
+    if (dbType === DatabaseClientType.ORACLE) {
+      finalConnection = {
+        user: username,
+        password,
+        connectString: `${finalHost}:${finalPort}/${targetName}`,
+        serviceName: targetName,
+        database: targetName
+      };
+    } else {
+      finalConnection = {
+        host: finalHost,
+        port: finalPort,
+        user: username,
+        password,
+        database: targetName
+      };
+    }
     if ((ssl == null ? void 0 : ssl.mode) && ssl.mode !== "disable") {
       finalConnection.ssl = {
         rejectUnauthorized: (_a = ssl.rejectUnauthorized) != null ? _a : true,
@@ -295,7 +938,7 @@ const getDatabaseSource = async ({
         key: ssl.key
       };
     }
-    cacheKey = `${dbType}://${username}@${host}:${port}/${database}${(ssh == null ? void 0 : ssh.enabled) ? "-ssh" : ""}${(ssl == null ? void 0 : ssl.mode) ? `-${ssl.mode}` : ""}`;
+    cacheKey = `${dbType}://${username}@${host}:${finalPort}/${targetName}${(ssh == null ? void 0 : ssh.enabled) ? "-ssh" : ""}${(ssl == null ? void 0 : ssl.mode) ? `-${ssl.mode}` : ""}`;
   }
   let cached = adapterCache.get(cacheKey);
   if (cached) {
@@ -312,55 +955,52 @@ const getDatabaseSource = async ({
 };
 async function healthCheckConnection({
   url,
-  type = DatabaseClientType.POSTGRES,
+  type,
+  method,
   host,
   port,
   username,
   password,
   database,
+  serviceName,
+  filePath,
   ssl,
   ssh
 }) {
-  var _a;
   let sshTunnelClose;
   try {
-    let finalConnection = url;
-    if (!url && host) {
-      let finalHost = host;
-      let finalPort = parseInt(port || "5432", 10);
-      if (ssh == null ? void 0 : ssh.enabled) {
-        const tunnel = await createSshTunnel(ssh, host, finalPort);
-        finalHost = tunnel.localHost;
-        finalPort = tunnel.localPort;
-        sshTunnelClose = tunnel.close;
-      }
-      finalConnection = {
-        host: finalHost,
-        port: finalPort,
-        user: username,
-        password,
-        database
-      };
-      if ((ssl == null ? void 0 : ssl.mode) && ssl.mode !== "disable") {
-        finalConnection.ssl = {
-          rejectUnauthorized: (_a = ssl.rejectUnauthorized) != null ? _a : true,
-          ca: ssl.ca,
-          cert: ssl.cert,
-          key: ssl.key
-        };
-      }
-    }
-    const adapter = createDatabaseAdapter(type, finalConnection);
+    const resolvedConnection = await resolveHealthCheckConnection({
+      url,
+      type,
+      method,
+      host,
+      port,
+      username,
+      password,
+      database,
+      serviceName,
+      filePath,
+      ssl,
+      ssh
+    });
+    const { connection } = resolvedConnection;
+    sshTunnelClose = resolvedConnection.sshTunnelClose;
+    const adapter = createDatabaseAdapter(type, connection);
     const isConnected = await adapter.healthCheck();
     await adapter.destroy();
     if (sshTunnelClose) await sshTunnelClose();
-    return isConnected;
+    return {
+      isConnectedSuccess: isConnected
+    };
   } catch (error) {
     console.error("Database connection failed:", error);
     if (sshTunnelClose) await sshTunnelClose();
-    return false;
+    return {
+      isConnectedSuccess: false,
+      message: (error == null ? void 0 : error.message) || "Database connection failed"
+    };
   }
 }
 
-export { DatabaseClientType as D, getDatabaseSource as g, healthCheckConnection as h };
+export { DatabaseClientType as D, MAX_RENDER_LIMIT as M, isMutationSql as a, MAX_EXPORT_LIMIT as b, clampLimit as c, getDatabaseSource as d, normalizeMysqlFields as e, normalizeOracleFields as f, getQualifiedTableName as g, healthCheckConnection as h, isSelectLikeSql as i, normalizeSql as n, quoteIdentifier as q, resolveFieldType as r };
 //# sourceMappingURL=db-connection.mjs.map