orcaq 1.0.33 → 1.1.2

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

@@ -1,73 +1,310 @@
+import { E as EManagedSqliteProvider, a as EConnectionProviderKind, b as EConnectionMethod, c as EConnectionFamily, p as pingRedisConnection } from './redis.client.mjs';
 import { e as createSshTunnel } from '../nitro/nitro.mjs';
 import knex from 'knex';
+import { Readable } from 'node:stream';
+import { createClient } from '@libsql/client/http';
+import * as oracledb from 'oracledb';
 import pg from 'pg';
+import { accessSync, constants } from 'node:fs';
 
 var DatabaseClientType = /* @__PURE__ */ ((DatabaseClientType2) => {
   DatabaseClientType2["POSTGRES"] = "postgres";
   DatabaseClientType2["MYSQL"] = "mysql";
+  DatabaseClientType2["MARIADB"] = "mariadb";
   DatabaseClientType2["MYSQL2"] = "mysql2";
+  DatabaseClientType2["REDIS"] = "redis";
   DatabaseClientType2["SQLITE3"] = "sqlite3";
+  DatabaseClientType2["SNOWFLAKE"] = "snowflake";
   DatabaseClientType2["BETTER_SQLITE3"] = "better-sqlite3";
   DatabaseClientType2["MSSQL"] = "mssql";
   DatabaseClientType2["ORACLE"] = "oracledb";
   return DatabaseClientType2;
 })(DatabaseClientType || {});
+const SQL_DATABASE_CLIENT_TYPES = [
+  "postgres" /* POSTGRES */,
+  "mysql" /* MYSQL */,
+  "mariadb" /* MARIADB */,
+  "mysql2" /* MYSQL2 */,
+  "sqlite3" /* SQLITE3 */,
+  "better-sqlite3" /* BETTER_SQLITE3 */,
+  "mssql" /* MSSQL */,
+  "oracledb" /* ORACLE */
+];
+const NOSQL_DATABASE_CLIENT_TYPES = ["redis" /* REDIS */];
 
-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 = {};
+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;
   }
-  async rawQuery(_sql, _bindings = []) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
+  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 rawOut(_sql, _bindings = []) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
+  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}`);
   }
-  streamQuery(_sql, _bindings = [], _options = {}) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
+  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 TabViewType = /* @__PURE__ */ ((TabViewType2) => {
+  TabViewType2["AllERD"] = "AllERD";
+  TabViewType2["DetailERD"] = "DetailERD";
+  TabViewType2["TableOverview"] = "TableOverview";
+  TabViewType2["TableDetail"] = "tableDetail";
+  TabViewType2["FunctionsOverview"] = "FunctionsOverview";
+  TabViewType2["FunctionsDetail"] = "FunctionsDetail";
+  TabViewType2["ViewOverview"] = "ViewOverview";
+  TabViewType2["ViewDetail"] = "ViewDetail";
+  TabViewType2["CodeQuery"] = "CodeQuery";
+  TabViewType2["UserPermissions"] = "UserPermissions";
+  TabViewType2["DatabaseTools"] = "DatabaseTools";
+  TabViewType2["InstanceInsights"] = "InstanceInsights";
+  TabViewType2["SchemaDiff"] = "SchemaDiff";
+  TabViewType2["Connection"] = "Connection";
+  TabViewType2["Explorer"] = "Explorer";
+  TabViewType2["Export"] = "Export";
+  TabViewType2["AgentChat"] = "AgentChat";
+  TabViewType2["RedisBrowser"] = "RedisBrowser";
+  TabViewType2["RedisPubSub"] = "RedisPubSub";
+  return TabViewType2;
+})(TabViewType || {});
+
+[
+  TabViewType.AllERD,
+  TabViewType.DetailERD,
+  TabViewType.TableOverview,
+  TabViewType.TableDetail,
+  TabViewType.FunctionsOverview,
+  TabViewType.FunctionsDetail,
+  TabViewType.ViewOverview,
+  TabViewType.ViewDetail,
+  TabViewType.CodeQuery,
+  TabViewType.UserPermissions,
+  TabViewType.DatabaseTools,
+  TabViewType.InstanceInsights,
+  TabViewType.SchemaDiff,
+  TabViewType.Connection,
+  TabViewType.Explorer,
+  TabViewType.Export,
+  TabViewType.AgentChat
+];
+[
+  TabViewType.CodeQuery,
+  TabViewType.Connection,
+  TabViewType.Explorer,
+  TabViewType.AgentChat,
+  TabViewType.RedisBrowser,
+  TabViewType.RedisPubSub,
+  TabViewType.InstanceInsights
+];
+({
+  [EConnectionFamily.SQL]: {
+    hiddenFeatureReasons: {
+      [TabViewType.RedisBrowser]: "Redis tools are only available for Redis connections."
+    }
+  }});
+function resolveConnectionProviderKind(input) {
+  var _a, _b;
+  if (input.providerKind) {
+    return input.providerKind;
   }
-  async acquireRawConnection() {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
+  if (input.type === DatabaseClientType.SQLITE3) {
+    if (((_a = input.managedSqlite) == null ? void 0 : _a.provider) === EManagedSqliteProvider.CLOUDFLARE_D1) {
+      return EConnectionProviderKind.CLOUDFLARE_D1;
+    }
+    if (((_b = input.managedSqlite) == null ? void 0 : _b.provider) === EManagedSqliteProvider.TURSO) {
+      return EConnectionProviderKind.TURSO;
+    }
+    if (input.method === EConnectionMethod.FILE) {
+      return EConnectionProviderKind.SQLITE_FILE;
+    }
   }
-  async releaseRawConnection(_connection) {
-    throw new Error(MYSQL_PLACEHOLDER_MESSAGE);
+  if (input.type === DatabaseClientType.REDIS) {
+    return EConnectionProviderKind.REDIS_DIRECT;
   }
-  async healthCheck() {
-    return false;
+  return EConnectionProviderKind.DIRECT_SQL;
+}
+function resolveConnectionFamily(input) {
+  const providerKind = resolveConnectionProviderKind(input);
+  if (providerKind === EConnectionProviderKind.REDIS_DIRECT) {
+    return EConnectionFamily.REDIS;
   }
-  getNativeSql(sql, _bindings) {
-    throw new Error(`${MYSQL_PLACEHOLDER_MESSAGE} SQL: ${sql}`);
+  if (NOSQL_DATABASE_CLIENT_TYPES.includes(input.type)) {
+    return EConnectionFamily.REDIS;
   }
-  async destroy() {
-    return;
+  if (SQL_DATABASE_CLIENT_TYPES.includes(input.type)) {
+    return EConnectionFamily.SQL;
   }
+  return EConnectionFamily.SQL;
 }
 
-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);
+function isNoSqlClientType(type) {
+  return type === DatabaseClientType.REDIS;
+}
+function buildUnsupportedConnectionMessage(input) {
+  if (input.family === EConnectionFamily.REDIS) {
+    return "Redis connections are supported, but they cannot be created through the SQL adapter stack.";
+  }
+  return "Only SQL-family connections are wired through the current runtime adapter stack.";
+}
+function assertSupportedConnectionRuntime(input) {
+  const isSupported = input.family === EConnectionFamily.SQL;
+  if (!isSupported) {
+    throw new Error(buildUnsupportedConnectionMessage(input));
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(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");
-    __publicField(this, "dbType");
-    __publicField(this, "connection");
+    __publicField$2(this, "knex");
+    __publicField$2(this, "dbType");
+    __publicField$2(this, "connection");
     this.dbType = dbType;
     this.connection = connection;
     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 +316,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 +335,489 @@ class BaseDatabaseAdapter {
   }
 }
 
+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, key + "" , value);
+class D1Adapter extends BaseDatabaseAdapter {
+  constructor(managedSqlite) {
+    super(
+      DatabaseClientType.SQLITE3,
+      createManagedSqliteConnectionString(
+        EConnectionProviderKind.CLOUDFLARE_D1,
+        managedSqlite
+      ),
+      createManagedSqliteKnex()
+    );
+    __publicField$1(this, "managedSqlite");
+    this.managedSqlite = managedSqlite;
+  }
+  get endpoint() {
+    if (!this.managedSqlite.accountId || !this.managedSqlite.databaseId) {
+      throw new Error("Cloudflare D1 requires both accountId and databaseId.");
+    }
+    return `https://api.cloudflare.com/client/v4/accounts/${this.managedSqlite.accountId}/d1/database/${this.managedSqlite.databaseId}/query`;
+  }
+  get headers() {
+    if (!this.managedSqlite.apiToken) {
+      throw new Error("Cloudflare D1 requires an API token.");
+    }
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.managedSqlite.apiToken}`
+    };
+  }
+  async executeStatement(sql, bindings = []) {
+    var _a, _b, _c;
+    const response = await fetch(this.endpoint, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        sql,
+        params: bindings
+      })
+    });
+    const payload = await response.json();
+    const message = (_b = (_a = payload.errors) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
+    if (!response.ok || payload.success === false) {
+      throw new Error(
+        message || `Cloudflare D1 request failed with status ${response.status}.`
+      );
+    }
+    const result = (_c = payload.result) == null ? void 0 : _c[0];
+    if (!result || result.success === false) {
+      throw new Error(message || "Cloudflare D1 query failed.");
+    }
+    return result;
+  }
+  async _rawQuery(sql, bindings = []) {
+    const result = await this.executeStatement(sql, bindings);
+    return normalizeRecordRows(result.results || []);
+  }
+  async _rawOut(sql, bindings = []) {
+    var _a, _b;
+    const result = await this.executeStatement(sql, bindings);
+    const rows = normalizeRecordRows(result.results || []);
+    const fields = createSyntheticFields$1(Object.keys(rows[0] || {}));
+    const rowCount = rows.length > 0 ? rows.length : (_b = (_a = result.meta) == null ? void 0 : _a.changes) != null ? _b : 0;
+    return {
+      rows: rowsToArray(rows, fields),
+      fields,
+      rowCount,
+      command: inferSqliteCommand$1(sql)
+    };
+  }
+  _streamQuery(sql, bindings = [], _options = {}) {
+    const adapter = this;
+    return Readable.from(
+      async function* () {
+        const rows = await adapter._rawQuery(
+          sql,
+          bindings
+        );
+        for (const row of rows) {
+          yield row;
+        }
+      }()
+    );
+  }
+  _getNativeSql(sql, bindings) {
+    return this.knex.raw(sql, bindings).toSQL().toNative();
+  }
+  async healthCheck() {
+    try {
+      await this.executeStatement("SELECT 1 AS health_check");
+      return true;
+    } catch (error) {
+      console.error("[D1Adapter] Health check failed", error);
+      return false;
+    }
+  }
+}
+
+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, key + "" , value);
+class TursoAdapter extends BaseDatabaseAdapter {
+  constructor(managedSqlite) {
+    super(
+      DatabaseClientType.SQLITE3,
+      createManagedSqliteConnectionString("turso", managedSqlite),
+      createManagedSqliteKnex()
+    );
+    this.managedSqlite = managedSqlite;
+    __publicField(this, "client");
+    if (!managedSqlite.url) {
+      throw new Error("Turso requires a database URL.");
+    }
+    if (!managedSqlite.authToken) {
+      throw new Error("Turso requires an auth token.");
+    }
+    this.client = createClient({
+      url: createManagedSqliteConnectionString("turso", managedSqlite),
+      authToken: managedSqlite.authToken
+    });
+  }
+  async executeStatement(sql, bindings = []) {
+    return await this.client.execute({
+      sql,
+      args: bindings
+    });
+  }
+  async _rawQuery(sql, bindings = []) {
+    const result = await this.executeStatement(sql, bindings);
+    return normalizeRecordRows(result.rows || []);
+  }
+  async _rawOut(sql, bindings = []) {
+    var _a, _b;
+    const result = await this.executeStatement(sql, bindings);
+    const rows = normalizeRecordRows(result.rows || []);
+    const fields = createSyntheticFields$1(
+      ((_a = result.columns) == null ? void 0 : _a.length) ? result.columns : Object.keys(rows[0] || {})
+    );
+    return {
+      rows: rowsToArray(rows, fields),
+      fields,
+      rowCount: (_b = result.rowsAffected) != null ? _b : rows.length,
+      command: inferSqliteCommand$1(sql)
+    };
+  }
+  _streamQuery(sql, bindings = [], _options = {}) {
+    const adapter = this;
+    return Readable.from(
+      async function* () {
+        const rows = await adapter._rawQuery(
+          sql,
+          bindings
+        );
+        for (const row of rows) {
+          yield row;
+        }
+      }()
+    );
+  }
+  _getNativeSql(sql, bindings) {
+    return this.knex.raw(sql, bindings).toSQL().toNative();
+  }
+  async healthCheck() {
+    try {
+      await this.executeStatement("SELECT 1 AS health_check");
+      return true;
+    } catch (error) {
+      console.error("[TursoAdapter] Health check failed", error);
+      return false;
+    }
+  }
+  async destroy() {
+    this.client.close();
+    await super.destroy();
+  }
+}
+
+function isManagedSqliteProviderKind(providerKind) {
+  return providerKind === EConnectionProviderKind.CLOUDFLARE_D1 || providerKind === EConnectionProviderKind.TURSO;
+}
+function createManagedSqliteConnectionString(providerKind, managedSqlite) {
+  if (providerKind === EConnectionProviderKind.CLOUDFLARE_D1) {
+    return `d1://${managedSqlite.accountId || ""}/${managedSqlite.databaseId || ""}`;
+  }
+  return buildTursoUrl(managedSqlite.url || "", managedSqlite.branchName);
+}
+function createManagedSqliteAdapter(options) {
+  if (!options.providerKind || !isManagedSqliteProviderKind(options.providerKind)) {
+    throw new Error("Managed SQLite adapters require a managed provider kind.");
+  }
+  if (!options.managedSqlite) {
+    throw new Error("Managed SQLite adapters require provider credentials.");
+  }
+  if (options.providerKind === EConnectionProviderKind.CLOUDFLARE_D1) {
+    return new D1Adapter(options.managedSqlite);
+  }
+  if (options.providerKind === EConnectionProviderKind.TURSO) {
+    return new TursoAdapter(options.managedSqlite);
+  }
+  throw new Error(
+    `Unsupported managed SQLite provider: ${options.providerKind}`
+  );
+}
+function createManagedSqliteKnex() {
+  return knex({
+    client: "sqlite3",
+    connection: {
+      filename: ":memory:"
+    },
+    useNullAsDefault: true,
+    pool: {
+      min: 1,
+      max: 1
+    }
+  });
+}
+function createSyntheticFields$1(columnNames) {
+  return columnNames.map((name, index) => ({
+    name,
+    tableID: 0,
+    columnID: index,
+    dataTypeID: 0,
+    dataTypeSize: 0,
+    dataTypeModifier: 0,
+    format: "text"
+  }));
+}
+function inferSqliteCommand$1(sql) {
+  var _a;
+  return ((_a = sql.trim().split(/\s+/, 1)[0]) == null ? void 0 : _a.toUpperCase()) || "";
+}
+function rowsToArray(rows, fields) {
+  return rows.map((row) => fields.map((field) => row[field.name]));
+}
+function normalizeRecordRows(rows) {
+  return rows.filter(Boolean).map((row) => ({ ...row }));
+}
+function buildTursoUrl(url, branchName) {
+  if (!branchName || !url) {
+    return url;
+  }
+  const nextUrl = new URL(url);
+  if (!nextUrl.searchParams.has("branch")) {
+    nextUrl.searchParams.set("branch", branchName);
+  }
+  return nextUrl.toString();
+}
+
+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,14 +910,198 @@ 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) {
+function createDatabaseAdapter(type, connection, options = {}) {
+  if (isNoSqlClientType(type)) {
+    throw new Error(
+      `${type} uses a dedicated NoSQL runtime and cannot be created through the SQL adapter factory.`
+    );
+  }
+  if (type === DatabaseClientType.SQLITE3 && isManagedSqliteProviderKind(options.providerKind)) {
+    return createManagedSqliteAdapter(options);
+  }
   const factory = ADAPTER_FACTORIES[type];
   if (!factory) {
     throw new Error(`Database type '${type}' is not supported yet.`);
@@ -207,6 +1111,18 @@ 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.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 +1171,133 @@ process.on("SIGTERM", async () => {
 process.on("exit", async () => {
   await shutdownAllAdapters();
 });
+function getDefaultPort(type) {
+  var _a;
+  return (_a = DEFAULT_PORTS[type]) != null ? _a : 5432;
+}
+function resolveRuntimeContext(input) {
+  var _a;
+  const providerKind = resolveConnectionProviderKind({
+    type: input.type,
+    method: input.method,
+    providerKind: input.providerKind,
+    managedSqlite: input.managedSqlite
+  });
+  const family = (_a = input.family) != null ? _a : resolveConnectionFamily({
+    type: input.type,
+    method: input.method,
+    providerKind,
+    managedSqlite: input.managedSqlite
+  });
+  return {
+    providerKind,
+    family
+  };
+}
+async function resolveHealthCheckConnection({
+  url,
+  type,
+  method,
+  host,
+  port,
+  username,
+  password,
+  database,
+  serviceName,
+  filePath,
+  providerKind,
+  family,
+  managedSqlite,
+  ssl,
+  ssh
+}) {
+  var _a;
+  let sshTunnelClose;
+  const runtimeContext = resolveRuntimeContext({
+    type,
+    method,
+    providerKind,
+    family,
+    managedSqlite
+  });
+  assertSupportedConnectionRuntime(runtimeContext);
+  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 (method === EConnectionMethod.MANAGED) {
+    if (!runtimeContext.providerKind || !isManagedSqliteProviderKind(runtimeContext.providerKind)) {
+      throw new Error(
+        "Managed SQLite health checks require a managed provider kind."
+      );
+    }
+    if (!managedSqlite) {
+      throw new Error(
+        "Managed SQLite health checks require provider credentials."
+      );
+    }
+    return {
+      connection: createManagedSqliteConnectionString(
+        runtimeContext.providerKind,
+        managedSqlite
+      ),
+      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,30 +1306,76 @@ const getDatabaseSource = async ({
   username,
   password,
   database,
+  serviceName,
+  filePath,
+  providerKind,
+  family,
+  managedSqlite,
   ssl,
   ssh
 }) => {
   var _a;
-  const dbType = type != null ? type : DatabaseClientType.POSTGRES;
+  if (!type) {
+    throw new Error("Database type is required to resolve a database adapter.");
+  }
+  const dbType = type;
+  const method = filePath ? EConnectionMethod.FILE : providerKind && isManagedSqliteProviderKind(providerKind) ? EConnectionMethod.MANAGED : managedSqlite && isManagedSqliteProviderKind(
+    resolveConnectionProviderKind({
+      type: dbType,
+      method: EConnectionMethod.MANAGED,
+      providerKind,
+      managedSqlite
+    })
+  ) ? EConnectionMethod.MANAGED : dbConnectionString ? EConnectionMethod.STRING : EConnectionMethod.FORM;
+  const runtimeContext = resolveRuntimeContext({
+    type: dbType,
+    method,
+    providerKind,
+    family,
+    managedSqlite
+  });
+  assertSupportedConnectionRuntime(runtimeContext);
   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 (method === EConnectionMethod.MANAGED && runtimeContext.providerKind && managedSqlite) {
+    finalConnection = createManagedSqliteConnectionString(
+      runtimeContext.providerKind,
+      managedSqlite
+    );
+    cacheKey = `${runtimeContext.providerKind}://${finalConnection}`;
+  } 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,14 +1384,17 @@ 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) {
     cached.lastUsed = Date.now();
     return cached.adapter;
   }
-  const newAdapter = createDatabaseAdapter(dbType, finalConnection);
+  const newAdapter = createDatabaseAdapter(dbType, finalConnection, {
+    providerKind: runtimeContext.providerKind,
+    managedSqlite
+  });
   adapterCache.set(cacheKey, {
     adapter: newAdapter,
     lastUsed: Date.now(),
@@ -312,55 +1404,84 @@ const getDatabaseSource = async ({
 };
 async function healthCheckConnection({
   url,
-  type = DatabaseClientType.POSTGRES,
+  type,
+  method,
   host,
   port,
   username,
   password,
   database,
+  serviceName,
+  filePath,
+  providerKind,
+  family,
+  managedSqlite,
   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,
+    const runtimeContext = resolveRuntimeContext({
+      type,
+      method,
+      providerKind,
+      family,
+      managedSqlite
+    });
+    if (runtimeContext.family === EConnectionFamily.REDIS) {
+      const isConnected2 = await pingRedisConnection({
+        method,
+        url,
+        host,
+        port,
+        username,
         password,
-        database
+        database,
+        ssl,
+        ssh
+      });
+      return {
+        isConnectedSuccess: isConnected2
       };
-      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,
+      providerKind,
+      family,
+      managedSqlite,
+      ssl,
+      ssh
+    });
+    const { connection } = resolvedConnection;
+    sshTunnelClose = resolvedConnection.sshTunnelClose;
+    const adapter = createDatabaseAdapter(type, connection, {
+      providerKind: runtimeContext.providerKind,
+      managedSqlite
+    });
     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