@edge-base/server 0.2.2 → 0.2.4

package/src/lib/d1-handler.ts

@@ -36,10 +36,11 @@ import { summarizeValidationErrors, validateInsert, validateUpdate } from './val
 import { buildEffectiveSchema } from './schema.js';
 import { generateId } from './uuid.js';
 import { parseUpdateBody } from './op-parser.js';
-import { emitDbLiveEvent, emitDbLiveBatchEvent, sendToDatabaseLiveDO } from './database-live-emitter.js';
+import { emitDbLiveEvent, emitDbLiveBatchEvent } from './database-live-emitter.js';
 import { isTrustedInternalContext } from './internal-request.js';
 import { executeDbTriggers } from './functions.js';
 import { forbiddenError, hookRejectedError, normalizeDatabaseError } from './errors.js';
+import { buildTableHookRuntimeServices } from './table-hook-runtime.js';
 
 // ─── Types ───
 
@@ -227,10 +228,11 @@ async function evalInsertRule(
 
 function buildHookCtx(
   db: D1Database,
-  tables: Record<string, TableConfig>,
   env: Env,
   executionCtx?: ExecutionContext,
 ): HookCtx {
+  const runtimeServices = buildTableHookRuntimeServices(parseConfig(env), env);
+
   return {
     db: {
       async get(table: string, id: string): Promise<Record<string, unknown> | null> {
@@ -266,20 +268,7 @@ function buildHookCtx(
         return result.rows.length > 0;
       },
     },
-    databaseLive: {
-      async broadcast(channel: string, event: string, data: unknown): Promise<void> {
-        await sendToDatabaseLiveDO(
-          env,
-          { channel, event, payload: data ?? {} },
-          '/internal/broadcast',
-        );
-      },
-    },
-    push: {
-      async send(_userId: string, _payload: { title?: string; body: string }): Promise<void> {
-        // Push notifications — same mechanism as DO (via Worker env)
-      },
-    },
+    ...runtimeServices,
     waitUntil(promise: Promise<unknown>): void {
       if (executionCtx) {
         executionCtx.waitUntil(promise);
@@ -288,6 +277,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 {
@@ -436,7 +437,7 @@ async function handleList(
 
   // Apply onEnrich hook
   if (tableHooks?.onEnrich) {
-    const hookCtx = buildHookCtx(resolved.db, resolved.dbBlock.tables ?? {}, c.env, c.executionCtx);
+    const hookCtx = buildHookCtx(resolved.db, c.env, c.executionCtx);
     for (let i = 0; i < items.length; i++) {
       try {
         const enriched = await tableHooks.onEnrich(auth, items[i], hookCtx);
@@ -600,7 +601,7 @@ async function handleGet(
 
   // Apply onEnrich hook
   if (tableHooks?.onEnrich) {
-    const hookCtx = buildHookCtx(resolved.db, resolved.dbBlock.tables ?? {}, c.env, c.executionCtx);
+    const hookCtx = buildHookCtx(resolved.db, c.env, c.executionCtx);
     try {
       const enriched = await tableHooks.onEnrich(auth, row, hookCtx);
       if (enriched && typeof enriched === 'object') return c.json({ ...row, ...enriched });
@@ -666,7 +667,7 @@ async function handleInsert(
   }
 
   // Run beforeInsert hook
-  const hookCtx = buildHookCtx(resolved.db, resolved.dbBlock.tables ?? {}, c.env, c.executionCtx);
+  const hookCtx = buildHookCtx(resolved.db, c.env, c.executionCtx);
   if (tableHooks?.beforeInsert) {
     try {
       const transformed = await tableHooks.beforeInsert(auth, body, hookCtx);
@@ -748,10 +749,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(
@@ -831,7 +834,7 @@ async function handleUpdate(
   }
 
   // Run beforeUpdate hook
-  const hookCtx = buildHookCtx(resolved.db, resolved.dbBlock.tables ?? {}, c.env, c.executionCtx);
+  const hookCtx = buildHookCtx(resolved.db, c.env, c.executionCtx);
   if (tableHooks?.beforeUpdate) {
     try {
       const transformed = await tableHooks.beforeUpdate(auth, existingRow, body, hookCtx);
@@ -891,9 +894,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(
@@ -947,7 +951,7 @@ async function handleDelete(
   }
 
   // Run beforeDelete hook
-  const hookCtx = buildHookCtx(resolved.db, resolved.dbBlock.tables ?? {}, c.env, c.executionCtx);
+  const hookCtx = buildHookCtx(resolved.db, c.env, c.executionCtx);
   if (tableHooks?.beforeDelete) {
     try {
       await tableHooks.beforeDelete(auth, existingRow, hookCtx);
@@ -969,9 +973,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 +1208,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 +1317,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.');
 }

package/src/lib/do-router.ts

@@ -8,11 +8,36 @@
  *
  * Constraint: `id` must NOT contain `:` character.
  */
-import { materializeConfig, type EdgeBaseConfig } from '@edge-base/shared';
+import { materializeConfig, type EdgeBaseConfig, type DbBlock } from '@edge-base/shared';
 import { counter } from '../middleware/rate-limit.js';
 
 const RUNTIME_CONFIG_GLOBAL_KEY = '__EDGEBASE_RUNTIME_CONFIG__';
 
+export type DbTargetValidationIssue =
+  | 'namespace_not_found'
+  | 'instance_id_empty'
+  | 'instance_id_invalid'
+  | 'instance_id_required'
+  | 'instance_id_not_allowed';
+
+export type DbTargetResolutionResult =
+  | {
+      ok: true;
+      value: {
+        namespace: string;
+        instanceId?: string;
+        dbBlock: DbBlock;
+        dynamic: boolean;
+      };
+    }
+  | {
+      ok: false;
+      issue: DbTargetValidationIssue;
+      status: 400 | 404;
+      namespace: string;
+      instanceId?: string;
+    };
+
 // ─── DO Instance ID Generation (§2) ───
 
 /**
@@ -53,6 +78,105 @@ export function parseDbDoName(doName: string): { namespace: string; id?: string
   };
 }
 
+export function normalizeDbInstanceId(instanceId: string | null | undefined): string | undefined {
+  return typeof instanceId === 'string' ? instanceId : undefined;
+}
+
+export function formatDbTargetValidationIssue(
+  issue: DbTargetValidationIssue,
+  namespace: string,
+  options: {
+    namespaceLabel?: string;
+    instanceIdLabel?: string;
+    includeSectionRef?: boolean;
+  } = {},
+): string {
+  const namespaceLabel = options.namespaceLabel ?? 'Database';
+  const instanceIdLabel = options.instanceIdLabel ?? 'instanceId';
+  switch (issue) {
+    case 'namespace_not_found':
+      return `${namespaceLabel} '${namespace}' not found in config`;
+    case 'instance_id_empty':
+      return `${instanceIdLabel} must not be empty`;
+    case 'instance_id_invalid':
+      return options.includeSectionRef
+        ? `${instanceIdLabel} must not contain ':' (§2)`
+        : `${instanceIdLabel} must not contain ':'`;
+    case 'instance_id_required':
+      return `${instanceIdLabel} is required for dynamic namespace '${namespace}'`;
+    case 'instance_id_not_allowed':
+      return `${instanceIdLabel} is not allowed for single-instance namespace '${namespace}'`;
+  }
+}
+
+export function resolveDbTarget(
+  config: EdgeBaseConfig,
+  namespace: string,
+  instanceId?: string | null,
+): DbTargetResolutionResult {
+  const normalizedInstanceId = normalizeDbInstanceId(instanceId);
+  const dbBlock = config.databases?.[namespace];
+  if (!dbBlock) {
+    return {
+      ok: false,
+      issue: 'namespace_not_found',
+      status: 404,
+      namespace,
+      instanceId: normalizedInstanceId,
+    };
+  }
+
+  if (normalizedInstanceId !== undefined && normalizedInstanceId.trim().length === 0) {
+    return {
+      ok: false,
+      issue: 'instance_id_empty',
+      status: 400,
+      namespace,
+      instanceId: normalizedInstanceId,
+    };
+  }
+
+  if (normalizedInstanceId?.includes(':')) {
+    return {
+      ok: false,
+      issue: 'instance_id_invalid',
+      status: 400,
+      namespace,
+      instanceId: normalizedInstanceId,
+    };
+  }
+
+  const dynamic = isDynamicDbBlock(dbBlock);
+  if (dynamic && normalizedInstanceId === undefined) {
+    return {
+      ok: false,
+      issue: 'instance_id_required',
+      status: 400,
+      namespace,
+      instanceId: normalizedInstanceId,
+    };
+  }
+  if (!dynamic && normalizedInstanceId !== undefined) {
+    return {
+      ok: false,
+      issue: 'instance_id_not_allowed',
+      status: 400,
+      namespace,
+      instanceId: normalizedInstanceId,
+    };
+  }
+
+  return {
+    ok: true,
+    value: {
+      namespace,
+      instanceId: normalizedInstanceId,
+      dbBlock,
+      dynamic,
+    },
+  };
+}
+
 // ─── DO Stub Call Helper ───
 
 /**
@@ -258,13 +382,21 @@ export function shouldRouteToD1(namespace: string, config: EdgeBaseConfig): bool
   if (dbBlock.provider === 'neon' || dbBlock.provider === 'postgres' || dbBlock.provider === 'do') return false;
 
   // Auto-detect: multi-tenant namespaces stay in DO
-  if (dbBlock.instance) return false;
-  if (dbBlock.access?.canCreate || dbBlock.access?.access) return false;
+  if (isDynamicDbBlock(dbBlock)) return false;
 
   // Default: single-instance → D1
   return true;
 }
 
+/**
+ * Dynamic DB blocks represent per-instance / multi-tenant storage and therefore
+ * require create/access authorization semantics that single-instance DB blocks do not.
+ */
+export function isDynamicDbBlock(dbBlock?: DbBlock): boolean {
+  if (!dbBlock) return false;
+  return Boolean(dbBlock.instance || dbBlock.access?.canCreate || dbBlock.access?.access);
+}
+
 /**
  * Get the D1 binding name for a single-instance namespace.
  * Convention: DB_D1_{NAMESPACE_UPPER}