@edge-base/server 0.2.2 → 0.2.3

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);
     },
 
+    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.sqlWithDirectD1Access() 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)`,
     );
   }