@edge-base/server 0.2.1 → 0.2.3

package/src/lib/internal-transport.ts

@@ -0,0 +1,316 @@
+/**
+ * Internal HttpTransport implementation for server-side function context.
+ *
+ * Replaces the old TableProxy by implementing the same HttpTransport interface
+ * that @edge-base/core's DefaultDbApi expects. This lets us use the real
+ * TableRef/DbRef classes from the core SDK while routing requests directly
+ * to D1, PostgreSQL, or DurableObject handlers — no HTTP round-trip.
+ */
+import type { HttpTransport } from '@edge-base/core';
+import type { EdgeBaseConfig } from '@edge-base/shared';
+import { getDbDoName, callDO, shouldRouteToD1 } from './do-router.js';
+import { handleD1Request } from './d1-handler.js';
+import { handlePgRequest } from './postgres-handler.js';
+import { buildInternalHandlerContext } from './internal-request.js';
+import type { Env } from '../types.js';
+
+export interface InternalTransportOptions {
+  databaseNamespace: DurableObjectNamespace;
+  config: EdgeBaseConfig;
+  workerUrl?: string;
+  serviceKey?: string;
+  env?: Env;
+  executionCtx?: ExecutionContext;
+  preferDirectDo?: boolean;
+  /**
+   * When set, the transport knows this DbRef targets a specific
+   * namespace + optional instanceId. This avoids ambiguous path parsing
+   * when instanceId happens to be "tables".
+   */
+  dbContext?: { namespace: string; instanceId?: string };
+}
+
+/**
+ * Parse a DefaultDbApi path into routing components.
+ *
+ * Paths follow two patterns:
+ *   /api/db/{namespace}/tables/{table}[/rest]                → static DB
+ *   /api/db/{namespace}/{instanceId}/tables/{table}[/rest]   → dynamic DB
+ *
+ * Returns namespace, optional instanceId, tableName, and directPath
+ * (everything from /tables/... onward, which D1/PG handlers expect).
+ */
+/**
+ * Parse a DefaultDbApi path, optionally guided by known dbContext.
+ *
+ * When dbContext is provided (recommended), we know whether this is a
+ * static or dynamic DB, so we can unambiguously find the 'tables' keyword
+ * even when instanceId === 'tables'.
+ *
+ * Without dbContext, falls back to heuristic: first 'tables' at index 1
+ * means static, at index 2 means dynamic.
+ */
+function parsePath(
+  path: string,
+  dbContext?: { namespace: string; instanceId?: string },
+): {
+  namespace: string;
+  instanceId?: string;
+  tableName: string;
+  directPath: string;
+} {
+  // Strip leading /api/db/
+  const stripped = path.replace(/^\/api\/db\//, '');
+  const segments = stripped.split('/');
+
+  let tablesIdx: number;
+  if (dbContext) {
+    // We know the shape: static has 'tables' at index 1, dynamic at index 2
+    tablesIdx = dbContext.instanceId ? 2 : 1;
+  } else {
+    // Heuristic fallback: find first 'tables' keyword
+    tablesIdx = segments.indexOf('tables', 1);
+  }
+  if (tablesIdx < 0 || segments[tablesIdx] !== 'tables') {
+    throw new Error(`Invalid DB path: missing 'tables' segment in ${path}`);
+  }
+
+  const namespace = segments[0];
+  const instanceId = tablesIdx === 2 ? segments[1] : undefined;
+  const rawTableName = segments[tablesIdx + 1];
+  // Decode URL-encoded table names (e.g. 'plugin-a%2Fevents' → 'plugin-a/events')
+  // Use decoded name consistently in both tableName and directPath so that
+  // handler suffix parsing (doPath.replace(`/tables/${tableName}`, '')) matches.
+  const tableName = decodeURIComponent(rawTableName);
+  const rest = segments.slice(tablesIdx + 2);
+  const directPath = `/tables/${tableName}${rest.length ? '/' + rest.join('/') : ''}`;
+
+  return { namespace, instanceId, tableName, directPath };
+}
+
+export class InternalHttpTransport implements HttpTransport {
+  private readonly databaseNamespace: DurableObjectNamespace;
+  private readonly config: EdgeBaseConfig;
+  private readonly workerUrl?: string;
+  private readonly serviceKey?: string;
+  private readonly env?: Env;
+  private readonly executionCtx?: ExecutionContext;
+  private readonly preferDirectDo: boolean;
+  private readonly dbContext?: { namespace: string; instanceId?: string };
+
+  constructor(options: InternalTransportOptions) {
+    this.databaseNamespace = options.databaseNamespace;
+    this.config = options.config;
+    this.workerUrl = options.workerUrl;
+    this.serviceKey = options.serviceKey;
+    this.env = options.env;
+    this.executionCtx = options.executionCtx;
+    this.preferDirectDo = options.preferDirectDo ?? false;
+    this.dbContext = options.dbContext;
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    options?: { query?: Record<string, string>; body?: unknown },
+  ): Promise<T> {
+    const { namespace, instanceId, tableName, directPath } = parsePath(path, this.dbContext);
+    const doName = getDbDoName(namespace, instanceId);
+
+    // Build internal headers
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-DO-Name': doName,
+      'X-EdgeBase-Internal': 'true',
+    };
+    if (this.serviceKey) {
+      headers['X-EdgeBase-Service-Key'] = this.serviceKey;
+    }
+
+    // Convert query Record to URLSearchParams
+    const query = new URLSearchParams();
+    if (options?.query) {
+      for (const [k, v] of Object.entries(options.query)) {
+        if (v !== undefined && v !== '') query.set(k, v);
+      }
+    }
+
+    const body = options?.body as Record<string, unknown> | undefined;
+
+    // Route to the appropriate handler
+    const res = await this.routeRequest(
+      method as 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT',
+      namespace,
+      instanceId,
+      tableName,
+      directPath,
+      doName,
+      headers,
+      query,
+      body,
+    );
+
+    if (!res.ok) {
+      const err = (await res.json().catch(() => ({}))) as Record<string, unknown>;
+      throw new Error(String(err.message || `Internal request failed: ${res.status}`));
+    }
+
+    return (await res.json()) as T;
+  }
+
+  async head(_path: string): Promise<boolean> {
+    // HEAD is only used by StorageClient.checkFileExists — not relevant for DB ops
+    return false;
+  }
+
+  private async routeRequest(
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT',
+    namespace: string,
+    instanceId: string | undefined,
+    tableName: string,
+    directPath: string,
+    doName: string,
+    headers: Record<string, string>,
+    query: URLSearchParams,
+    body?: Record<string, unknown>,
+  ): Promise<Response> {
+    const queryString = Array.from(query.keys()).length > 0 ? `?${query.toString()}` : '';
+    const directPathWithQuery = `${directPath}${queryString}`;
+    const provider = this.config.databases?.[namespace]?.provider;
+    const httpMethod = method === 'PUT' ? 'PATCH' : method; // normalize PUT → PATCH
+
+    // 1. D1 route
+    if (!this.preferDirectDo && shouldRouteToD1(namespace, this.config) && this.env) {
+      return this.requestViaD1Handler(httpMethod, namespace, instanceId, tableName, directPath, headers, query, body);
+    }
+
+    // 2. PostgreSQL route
+    if ((provider === 'neon' || provider === 'postgres') && this.env) {
+      return this.requestViaPgHandler(httpMethod, namespace, instanceId, tableName, directPath, headers, query, body);
+    }
+
+    // 3. Direct DO route
+    if (this.env) {
+      return this.requestViaDirectDo(httpMethod, doName, directPathWithQuery, headers, body, !!instanceId);
+    }
+
+    // 4. Worker HTTP fallback
+    if (this.workerUrl) {
+      const apiPath = instanceId
+        ? `/api/db/${namespace}/${instanceId}${directPathWithQuery}`
+        : `/api/db/${namespace}${directPathWithQuery}`;
+      return this.requestViaWorker(httpMethod, apiPath, headers, body);
+    }
+
+    // 5. Fallback: direct DO
+    return this.requestViaDirectDo(httpMethod, doName, directPathWithQuery, headers, body, !!instanceId);
+  }
+
+  private async requestViaWorker(
+    method: string,
+    path: string,
+    headers: Record<string, string>,
+    body?: Record<string, unknown>,
+  ): Promise<Response> {
+    return fetch(`${this.workerUrl}${path}`, {
+      method,
+      headers,
+      body: body === undefined || method === 'GET' || method === 'DELETE'
+        ? undefined
+        : JSON.stringify(body),
+    });
+  }
+
+  private async requestViaD1Handler(
+    method: string,
+    namespace: string,
+    instanceId: string | undefined,
+    tableName: string,
+    directPath: string,
+    headers: Record<string, string>,
+    query: URLSearchParams,
+    body?: Record<string, unknown>,
+  ): Promise<Response> {
+    if (!this.env) throw new Error('D1 table proxy requires env.');
+
+    const queryString = Array.from(query.keys()).length > 0 ? `?${query.toString()}` : '';
+    const url = `http://internal/api/db/${namespace}${instanceId ? `/${instanceId}` : ''}${directPath}${queryString}`;
+
+    const request = new Request(url, {
+      method,
+      headers,
+      body: body === undefined || method === 'GET' || method === 'DELETE'
+        ? undefined
+        : JSON.stringify(body),
+    });
+
+    return handleD1Request(
+      buildInternalHandlerContext({ env: this.env, request, body, executionCtx: this.executionCtx }),
+      namespace,
+      tableName,
+      directPath,
+    );
+  }
+
+  private async requestViaPgHandler(
+    method: string,
+    namespace: string,
+    instanceId: string | undefined,
+    tableName: string,
+    directPath: string,
+    headers: Record<string, string>,
+    query: URLSearchParams,
+    body?: Record<string, unknown>,
+  ): Promise<Response> {
+    if (!this.env) throw new Error('PostgreSQL table proxy requires env.');
+
+    const queryString = Array.from(query.keys()).length > 0 ? `?${query.toString()}` : '';
+    const url = `http://internal/api/db/${namespace}${instanceId ? `/${instanceId}` : ''}${directPath}${queryString}`;
+
+    const request = new Request(url, {
+      method,
+      headers,
+      body: body === undefined || method === 'GET' || method === 'DELETE'
+        ? undefined
+        : JSON.stringify(body),
+    });
+
+    return handlePgRequest(
+      buildInternalHandlerContext({ env: this.env, request, body, executionCtx: this.executionCtx }),
+      namespace,
+      tableName,
+      directPath,
+    );
+  }
+
+  private async requestViaDirectDo(
+    method: string,
+    doName: string,
+    directPathWithQuery: string,
+    headers: Record<string, string>,
+    body?: Record<string, unknown>,
+    isDynamic?: boolean,
+  ): Promise<Response> {
+    const res = await callDO(this.databaseNamespace, doName, directPathWithQuery, {
+      method,
+      body,
+      headers,
+    });
+
+    // Handle dynamic DO creation
+    if (isDynamic && res.status === 201) {
+      const createPayload = await res.clone().json().catch(() => null) as
+        | { needsCreate?: boolean }
+        | null;
+      if (createPayload?.needsCreate) {
+        return callDO(this.databaseNamespace, doName, directPathWithQuery, {
+          method,
+          body,
+          headers: { ...headers, 'X-DO-Create-Authorized': '1' },
+        });
+      }
+    }
+
+    return res;
+  }
+}

package/src/lib/plugin-migrations.ts

@@ -33,7 +33,7 @@ import {
   buildFunctionPushProxy,
   buildAdminAuthContext,
 } from './functions.js';
-import { executeDoSql } from './do-sql.js';
+import { executeProviderAwareSql } from './provider-aware-sql.js';
 import { resolveRootServiceKey } from './service-key.js';
 
 /**
@@ -118,9 +118,9 @@ function arePluginMigrationsCurrentInMemory(plugins: PluginInstance[]): boolean
     return false;
   }
 
-  return versionedPlugins.every((plugin) => (
-    currentVersionedPlugins.get(plugin.name) === plugin.version
-  ));
+  return versionedPlugins.every(
+    (plugin) => currentVersionedPlugins.get(plugin.name) === plugin.version,
+  );
 }
 
 function markPluginsCurrent(plugins: PluginInstance[]): void {
@@ -217,7 +217,8 @@ async function runMigrationsWithTimeout(
 }
 
 function resolvePluginMigrationTimeoutMs(): number {
-  const raw = typeof process !== 'undefined' ? process.env.EDGEBASE_PLUGIN_MIGRATIONS_TIMEOUT_MS : undefined;
+  const raw =
+    typeof process !== 'undefined' ? process.env.EDGEBASE_PLUGIN_MIGRATIONS_TIMEOUT_MS : undefined;
   const parsed = Number(raw);
   if (Number.isFinite(parsed) && parsed > 0) {
     return parsed;
@@ -250,9 +251,9 @@ async function arePluginMigrationsCurrent(
   );
   const versions = new Map(rows.map((row) => [row.key, row.value]));
 
-  return versionedPlugins.every((plugin) => (
-    versions.get(`plugin_version:${plugin.name}`) === plugin.version
-  ));
+  return versionedPlugins.every(
+    (plugin) => versions.get(`plugin_version:${plugin.name}`) === plugin.version,
+  );
 }
 
 // ─── Helpers ───
@@ -334,6 +335,28 @@ function buildMigrationAdminContext(
     return directUrl ?? null;
   }
 
+  const sqlProviderAware = async (
+    namespace: string,
+    id: string | undefined,
+    query: string,
+    params?: unknown[],
+  ): Promise<unknown[]> => {
+    const result = await executeProviderAwareSql(
+      {
+        env,
+        config,
+        databaseNamespace: dbNamespace,
+        workerUrl,
+        serviceKey,
+      },
+      namespace,
+      id,
+      query,
+      params ?? [],
+    );
+    return result.rows as unknown[];
+  };
+
   return {
     db(namespace: string, id?: string) {
       const pgConnStr = resolvePgConnString(namespace);
@@ -350,40 +373,14 @@ function buildMigrationAdminContext(
       return doAdminDb(namespace, id);
     },
 
-    async sql(
+    sqlProviderAware,
+    async sqlWithDirectD1Access(
       namespace: string,
       id: string | undefined,
       query: string,
       params?: unknown[],
     ): Promise<unknown[]> {
-      const dbBlock = config.databases?.[namespace];
-      const isDynamicNamespace = !!(dbBlock?.instance || dbBlock?.access?.canCreate || dbBlock?.access?.access);
-      if (isDynamicNamespace && !id) {
-        throw new Error(`admin.sql() requires an id for dynamic namespace '${namespace}'.`);
-      }
-
-      const pgConnStr = resolvePgConnString(namespace);
-
-      // ─── PostgreSQL path ───
-      if (pgConnStr) {
-        // Ensure schema is initialized before raw SQL
-        const dbBlock = config.databases?.[namespace];
-        if (dbBlock?.tables) {
-          await ensurePgSchema(pgConnStr, namespace, dbBlock.tables);
-        }
-        const result = await executePostgresQuery(pgConnStr, query, params ?? []);
-        return result.rows as unknown[];
-      }
-
-      // ─── DO path (existing) ───
-      return executeDoSql({
-        databaseNamespace: dbNamespace,
-        namespace,
-        id,
-        query,
-        params: params ?? [],
-        internal: true,
-      });
+      return sqlProviderAware(namespace, id, query, params);
     },
 
     // ─── Convenience shortcut: table(name) → db('shared').table(name) ───
@@ -523,7 +520,8 @@ function buildPgTableOps(
       const setClauses = (updatableCols.length > 0 ? updatableCols : [conflictTarget]).map(
         (col) => `${escapePgIdentifier(col)} = EXCLUDED.${escapePgIdentifier(col)}`,
       );
-      const sql = `INSERT INTO ${escapePgIdentifier(tableName)} (${cols.map(escapePgIdentifier).join(', ')}) VALUES (${placeholders.join(', ')})` +
+      const sql =
+        `INSERT INTO ${escapePgIdentifier(tableName)} (${cols.map(escapePgIdentifier).join(', ')}) VALUES (${placeholders.join(', ')})` +
         ` ON CONFLICT (${escapePgIdentifier(conflictTarget)}) DO UPDATE SET ${setClauses.join(', ')} RETURNING *`;
       const result = await executePostgresQuery(connectionString, sql, vals);
       return result.rows[0]
@@ -596,7 +594,9 @@ function buildPgTableOps(
       }
 
       const result = await executePostgresQuery(connectionString, sql, params);
-      return { items: result.rows.map((row) => stripInternalPgFields(row as Record<string, unknown>)) };
+      return {
+        items: result.rows.map((row) => stripInternalPgFields(row as Record<string, unknown>)),
+      };
     },
   };
 }

package/src/lib/postgres-handler.ts

@@ -298,6 +298,18 @@ function buildHookCtx(
   };
 }
 
+function scheduleDbLive(
+  executionCtx: ExecutionContext,
+  promise: Promise<void>,
+  context: string,
+): void {
+  executionCtx.waitUntil(
+    promise.catch((error) => {
+      console.warn(`[db-live] ${context} failed`, error);
+    }),
+  );
+}
+
 function toFieldErrorData(
   errors: Record<string, string>,
 ): Record<string, { code: string; message: string }> {
@@ -605,7 +617,8 @@ async function handleInsert(
   }
 
   // Emit database-live event (fire-and-forget)
-  c.executionCtx.waitUntil(
+  scheduleDbLive(
+    c.executionCtx,
     emitDbLiveEvent(
       c.env,
       resolved.namespace,
@@ -614,6 +627,7 @@ async function handleInsert(
       String(inserted.id ?? ''),
       inserted,
     ),
+    `emit ${isUpsert && isUpdate ? 'modified' : 'added'} ${resolved.namespace}.${tableName}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -733,8 +747,10 @@ async function handleUpdate(
   }
 
   // Emit database-live event (fire-and-forget)
-  c.executionCtx.waitUntil(
+  scheduleDbLive(
+    c.executionCtx,
     emitDbLiveEvent(c.env, resolved.namespace, tableName, 'modified', id, updated),
+    `emit modified ${resolved.namespace}.${tableName}:${id}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -817,8 +833,10 @@ async function handleDelete(
   }
 
   // Emit database-live event (fire-and-forget)
-  c.executionCtx.waitUntil(
+  scheduleDbLive(
+    c.executionCtx,
     emitDbLiveEvent(c.env, resolved.namespace, tableName, 'removed', id, stripInternalPgFields(existingRow)),
+    `emit removed ${resolved.namespace}.${tableName}:${id}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -944,15 +962,21 @@ async function handleBatch(
       data: r as Record<string, unknown>,
     }));
     if (changes.length >= 10) {
-      c.executionCtx.waitUntil(
+      scheduleDbLive(
+        c.executionCtx,
         emitDbLiveBatchEvent(c.env, resolved.namespace, tableName, changes),
+        `emit batch ${resolved.namespace}.${tableName} (${changes.length} changes)`,
       );
     } else {
-      for (const ch of changes) {
-        c.executionCtx.waitUntil(
-          emitDbLiveEvent(c.env, resolved.namespace, tableName, ch.type, ch.docId, ch.data),
-        );
-      }
+      scheduleDbLive(
+        c.executionCtx,
+        Promise.all(
+          changes.map((ch) =>
+            emitDbLiveEvent(c.env, resolved.namespace, tableName, ch.type, ch.docId, ch.data),
+          ),
+        ).then(() => undefined),
+        `emit fan-out ${resolved.namespace}.${tableName} (${changes.length} changes)`,
+      );
     }
   }
 
@@ -1031,8 +1055,10 @@ async function handleBatchByFilter(
     succeeded = result.rowCount;
 
     if (succeeded > 0) {
-      c.executionCtx.waitUntil(
+      scheduleDbLive(
+        c.executionCtx,
         emitDbLiveEvent(c.env, resolved.namespace, tableName, 'removed', '_bulk', { action: 'delete', count: succeeded }),
+        `emit bulk ${resolved.namespace}.${tableName} (delete)`,
       );
     }
 
@@ -1074,8 +1100,10 @@ async function handleBatchByFilter(
   succeeded = result.rowCount;
 
   if (succeeded > 0) {
-    c.executionCtx.waitUntil(
+    scheduleDbLive(
+      c.executionCtx,
       emitDbLiveEvent(c.env, resolved.namespace, tableName, 'modified', '_bulk', { action: 'update', count: succeeded }),
+      `emit bulk ${resolved.namespace}.${tableName} (update)`,
     );
   }