orcaq 1.1.1 → 1.1.3

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

@@ -1,16 +1,17 @@
+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';
-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";
@@ -19,6 +20,17 @@ var DatabaseClientType = /* @__PURE__ */ ((DatabaseClientType2) => {
   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 */];
 
 const DEFAULT_RENDER_LIMIT = 100;
 const MAX_RENDER_LIMIT = 500;
@@ -159,16 +171,117 @@ function resolveFieldType(field) {
   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 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 || {});
 
-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);
+[
+  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;
+  }
+  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;
+    }
+  }
+  if (input.type === DatabaseClientType.REDIS) {
+    return EConnectionProviderKind.REDIS_DIRECT;
+  }
+  return EConnectionProviderKind.DIRECT_SQL;
+}
+function resolveConnectionFamily(input) {
+  const providerKind = resolveConnectionProviderKind(input);
+  if (providerKind === EConnectionProviderKind.REDIS_DIRECT) {
+    return EConnectionFamily.REDIS;
+  }
+  if (NOSQL_DATABASE_CLIENT_TYPES.includes(input.type)) {
+    return EConnectionFamily.REDIS;
+  }
+  if (SQL_DATABASE_CLIENT_TYPES.includes(input.type)) {
+    return EConnectionFamily.SQL;
+  }
+  return EConnectionFamily.SQL;
+}
+
+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;
@@ -177,9 +290,9 @@ const normalizeBindableSql = (sql, bindings) => {
 };
 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;
@@ -222,6 +335,255 @@ 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;
@@ -731,7 +1093,15 @@ const ADAPTER_FACTORIES = {
   [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.`);
@@ -746,7 +1116,6 @@ const DEFAULT_PORTS = {
   [DatabaseClientType.MYSQL]: 3306,
   [DatabaseClientType.MARIADB]: 3306,
   [DatabaseClientType.MYSQL2]: 3306,
-  [DatabaseClientType.MONGODB]: 27017,
   [DatabaseClientType.REDIS]: 6379,
   [DatabaseClientType.MSSQL]: 1433,
   [DatabaseClientType.ORACLE]: 1521,
@@ -806,6 +1175,25 @@ 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,
@@ -817,11 +1205,22 @@ async function resolveHealthCheckConnection({
   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(
@@ -844,6 +1243,25 @@ async function resolveHealthCheckConnection({
       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.");
   }
@@ -890,11 +1308,33 @@ const getDatabaseSource = async ({
   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;
@@ -904,6 +1344,12 @@ const getDatabaseSource = async ({
       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 || `${getDefaultPort(dbType)}`, 10);
@@ -945,7 +1391,10 @@ const getDatabaseSource = async ({
     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(),
@@ -964,11 +1413,37 @@ async function healthCheckConnection({
   database,
   serviceName,
   filePath,
+  providerKind,
+  family,
+  managedSqlite,
   ssl,
   ssh
 }) {
   let sshTunnelClose;
   try {
+    const runtimeContext = resolveRuntimeContext({
+      type,
+      method,
+      providerKind,
+      family,
+      managedSqlite
+    });
+    if (runtimeContext.family === EConnectionFamily.REDIS) {
+      const isConnected2 = await pingRedisConnection({
+        method,
+        url,
+        host,
+        port,
+        username,
+        password,
+        database,
+        ssl,
+        ssh
+      });
+      return {
+        isConnectedSuccess: isConnected2
+      };
+    }
     const resolvedConnection = await resolveHealthCheckConnection({
       url,
       type,
@@ -980,12 +1455,18 @@ async function healthCheckConnection({
       database,
       serviceName,
       filePath,
+      providerKind,
+      family,
+      managedSqlite,
       ssl,
       ssh
     });
     const { connection } = resolvedConnection;
     sshTunnelClose = resolvedConnection.sshTunnelClose;
-    const adapter = createDatabaseAdapter(type, connection);
+    const adapter = createDatabaseAdapter(type, connection, {
+      providerKind: runtimeContext.providerKind,
+      managedSqlite
+    });
     const isConnected = await adapter.healthCheck();
     await adapter.destroy();
     if (sshTunnelClose) await sshTunnelClose();