@edge-base/server 0.2.1 → 0.2.3

package/src/lib/d1-handler.ts

@@ -288,6 +288,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);
+    }),
+  );
+}
+
 // ─── Utility ───
 
 function esc(name: string): string {
@@ -748,10 +760,12 @@ async function handleInsert(
     hookCtx.waitUntil(Promise.resolve(hook(inserted, hookCtx)).catch(() => {}));
   }
 
-  // Emit database-live event (fire-and-forget)
+  // Emit database-live event in the background so writes stay fast.
   const eventType = isUpsert && isUpdate ? 'modified' : 'added';
-  c.executionCtx.waitUntil(
+  scheduleDbLive(
+    c.executionCtx,
     emitDbLiveEvent(c.env, resolved.namespace, tableName, eventType, String(inserted.id ?? ''), inserted),
+    `emit ${eventType} ${resolved.namespace}.${tableName}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -891,9 +905,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(
@@ -969,9 +984,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, stripInternalFields(existingRow)),
+    `emit removed ${resolved.namespace}.${tableName}:${id}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -1203,15 +1219,21 @@ async function handleBatch(
   // Emit database-live events
   if (allChanges.length > 0) {
     if (allChanges.length >= 10) {
-      c.executionCtx.waitUntil(
+      scheduleDbLive(
+        c.executionCtx,
         emitDbLiveBatchEvent(c.env, resolved.namespace, tableName, allChanges),
+        `emit batch ${resolved.namespace}.${tableName} (${allChanges.length} changes)`,
       );
     } else {
-      for (const ch of allChanges) {
-        c.executionCtx.waitUntil(
-          emitDbLiveEvent(c.env, resolved.namespace, tableName, ch.type, ch.docId, ch.data),
-        );
-      }
+      scheduleDbLive(
+        c.executionCtx,
+        Promise.all(
+          allChanges.map((ch) =>
+            emitDbLiveEvent(c.env, resolved.namespace, tableName, ch.type, ch.docId, ch.data),
+          ),
+        ).then(() => undefined),
+        `emit fan-out ${resolved.namespace}.${tableName} (${allChanges.length} changes)`,
+      );
     }
   }
 
@@ -1306,8 +1328,17 @@ async function handleBatchByFilter(
   // Emit database-live events
   if (succeeded > 0) {
     const eventType = body.action === 'delete' ? 'removed' : 'modified';
-    c.executionCtx.waitUntil(
-      emitDbLiveEvent(c.env, resolved.namespace, tableName, eventType as 'modified' | 'removed', '_bulk', { action: body.action, count: succeeded }),
+    scheduleDbLive(
+      c.executionCtx,
+      emitDbLiveEvent(
+        c.env,
+        resolved.namespace,
+        tableName,
+        eventType as 'modified' | 'removed',
+        '_bulk',
+        { action: body.action, count: succeeded },
+      ),
+      `emit bulk ${resolved.namespace}.${tableName} (${body.action})`,
     );
   }
 

package/src/lib/database-live-emitter.ts

@@ -1,7 +1,7 @@
 /**
  * Shared database live event emission helpers.
  *
- * Used by d1-handler.ts and postgres-handler.ts for fire-and-forget
+ * Used by d1-handler.ts and postgres-handler.ts for background
  * event delivery to DatabaseLiveDO after successful CUD operations.
  *
  * database-do.ts keeps its own internal version (uses DO env).
@@ -10,6 +10,16 @@ import type { Env } from '../types.js';
 
 export const DATABASE_LIVE_HUB_DO_NAME = 'database-live:hub';
 
+function withDeliveryId(event: Record<string, unknown>): Record<string, unknown> {
+  if (typeof event.deliveryId === 'string' && event.deliveryId.length > 0) {
+    return event;
+  }
+  return {
+    ...event,
+    deliveryId: crypto.randomUUID(),
+  };
+}
+
 export function buildDbLiveChannel(
   namespace: string,
   table: string,
@@ -34,7 +44,7 @@ export function isDbLiveChannel(channel: string): boolean {
 
 /**
  * Emit a single CUD event to DatabaseLiveDO.
- * Mirrors database-do.ts emitDbLiveEvent() — fire-and-forget.
+ * Mirrors database-do.ts emitDbLiveEvent().
  */
 export function emitDbLiveEvent(
   env: Env,
@@ -87,25 +97,56 @@ export function emitDbLiveBatchEvent(
   return sendToDatabaseLiveDO(env, event, '/internal/batch-event');
 }
 
+async function postToDatabaseLiveDO(
+  env: Env,
+  event: Record<string, unknown>,
+  path = '/internal/event',
+): Promise<void> {
+  const liveNamespace = env.DATABASE_LIVE;
+  if (!liveNamespace) {
+    return;
+  }
+
+  const doId = liveNamespace.idFromName(DATABASE_LIVE_HUB_DO_NAME);
+  const stub = liveNamespace.get(doId);
+  const response = await stub.fetch(`http://internal${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(event),
+  });
+
+  if (!response.ok) {
+    const detail = await response.text().catch(() => '');
+    const suffix = detail ? `: ${detail.slice(0, 200)}` : '';
+    throw new Error(`DatabaseLiveDO ${path} failed with ${response.status}${suffix}`);
+  }
+}
+
 /**
- * Fire-and-forget: send event to DatabaseLiveDO via stub.fetch().
- * Never blocks CRUD response — errors are silently ignored.
+ * Send an event to DatabaseLiveDO via stub.fetch().
+ * Callers should schedule this with waitUntil() when they want
+ * fire-and-forget request semantics without hiding delivery failures.
  */
-export function sendToDatabaseLiveDO(
+export async function sendToDatabaseLiveDO(
   env: Env,
   event: Record<string, unknown>,
   path = '/internal/event',
 ): Promise<void> {
-  try {
-    const doId = env.DATABASE_LIVE.idFromName(DATABASE_LIVE_HUB_DO_NAME);
-    const stub = env.DATABASE_LIVE.get(doId);
-    return stub.fetch(`http://internal${path}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(event),
-    }).then(() => undefined).catch(() => undefined);
-  } catch {
-    // Ignore — database live delivery should not block database operations
-    return Promise.resolve();
+  const eventWithDeliveryId = withDeliveryId(event);
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      await postToDatabaseLiveDO(env, eventWithDeliveryId, path);
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  if (lastError instanceof Error) {
+    throw lastError;
   }
+
+  throw new Error('DatabaseLiveDO delivery failed.');
 }