@edge-base/server 0.2.2 → 0.2.4

package/src/lib/plugin-migration-routing.ts

@@ -0,0 +1,28 @@
+const PLUGIN_MIGRATION_PATH_PREFIXES = [
+  '/api/auth',
+  '/api/db',
+  '/api/functions',
+  '/api/sql',
+  '/api/storage',
+  '/admin/api',
+] as const;
+
+export function shouldRunPluginMigrationsForRequestPath(path: string): boolean {
+  if (!path.startsWith('/')) {
+    path = `/${path}`;
+  }
+
+  if (
+    path === '/admin/api/backup'
+    || path.startsWith('/admin/api/backup/')
+    || path.startsWith('/admin/api/data/backup/')
+    || path === '/internal/backup'
+    || path.startsWith('/internal/backup/')
+  ) {
+    return false;
+  }
+
+  return PLUGIN_MIGRATION_PATH_PREFIXES.some(
+    (prefix) => path === prefix || path.startsWith(`${prefix}/`),
+  );
+}

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

@@ -51,6 +51,7 @@ import {
 import { isTrustedInternalContext } from './internal-request.js';
 import { executeDbTriggers } from './functions.js';
 import { parseUpdateBody } from './op-parser.js';
+import { buildTableHookRuntimeServices } from './table-hook-runtime.js';
 
 // ─── Types ───
 
@@ -232,13 +233,14 @@ async function evalInsertRule(
 
 function buildHookCtx(
   connectionString: string,
-  tables: Record<string, TableConfig>,
+  env: Env,
   executionCtx?: ExecutionContext,
   queryExecutor?: PostgresExecutor,
 ): HookCtx {
   const query =
     queryExecutor ??
     ((sql: string, params: unknown[] = []) => executePostgresQuery(connectionString, sql, params));
+  const runtimeServices = buildTableHookRuntimeServices(parseConfig(env), env);
 
   return {
     db: {
@@ -279,17 +281,7 @@ function buildHookCtx(
         return result.rows.length > 0;
       },
     },
-    databaseLive: {
-      async broadcast(_channel: string, _event: string, _data: unknown): Promise<void> {
-        // HookCtx broadcast — not implemented for PostgreSQL provider (no direct env access)
-        // Use database-live subscription from client SDK instead
-      },
-    },
-    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);
@@ -298,6 +290,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 }> {
@@ -346,7 +350,7 @@ async function handleList(
 
   // Apply onEnrich hook
   if (tableHooks?.onEnrich) {
-    const hookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx, query);
+    const hookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx, query);
     for (let i = 0; i < items.length; i++) {
       try {
         const enriched = await tableHooks.onEnrich(auth, items[i], hookCtx);
@@ -495,7 +499,7 @@ async function handleGet(
 
   // Apply onEnrich hook
   if (tableHooks?.onEnrich) {
-    const hookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx, query);
+    const hookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx, query);
     try {
       const enriched = await tableHooks.onEnrich(auth, row, hookCtx);
       if (enriched && typeof enriched === 'object') return c.json({ ...row, ...enriched });
@@ -546,7 +550,7 @@ async function handleInsert(
   }
 
   // Run beforeInsert hook
-  const requestHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx, query);
+  const requestHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx, query);
   if (tableHooks?.beforeInsert) {
     try {
       const transformed = await tableHooks.beforeInsert(auth, body, requestHookCtx);
@@ -600,12 +604,13 @@ async function handleInsert(
   // Run afterInsert hook (fire-and-forget)
   if (tableHooks?.afterInsert) {
     const hook = tableHooks.afterInsert;
-    const backgroundHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx);
+    const backgroundHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx);
     backgroundHookCtx.waitUntil(Promise.resolve(hook(inserted, backgroundHookCtx)).catch(() => {}));
   }
 
   // Emit database-live event (fire-and-forget)
-  c.executionCtx.waitUntil(
+  scheduleDbLive(
+    c.executionCtx,
     emitDbLiveEvent(
       c.env,
       resolved.namespace,
@@ -614,6 +619,7 @@ async function handleInsert(
       String(inserted.id ?? ''),
       inserted,
     ),
+    `emit ${isUpsert && isUpdate ? 'modified' : 'added'} ${resolved.namespace}.${tableName}`,
   );
   c.executionCtx.waitUntil(
     executeDbTriggers(
@@ -689,7 +695,7 @@ async function handleUpdate(
   }
 
   // Run beforeUpdate hook
-  const requestHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx, query);
+  const requestHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx, query);
   if (tableHooks?.beforeUpdate) {
     try {
       const transformed = await tableHooks.beforeUpdate(auth, existingRow, body, requestHookCtx);
@@ -726,15 +732,17 @@ async function handleUpdate(
   // Run afterUpdate hook (fire-and-forget)
   if (tableHooks?.afterUpdate) {
     const hook = tableHooks.afterUpdate;
-    const backgroundHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx);
+    const backgroundHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx);
     backgroundHookCtx.waitUntil(
       Promise.resolve(hook(existingRow, updated, backgroundHookCtx)).catch(() => {}),
     );
   }
 
   // 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(
@@ -789,7 +797,7 @@ async function handleDelete(
   }
 
   // Run beforeDelete hook
-  const requestHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx, query);
+  const requestHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx, query);
   if (tableHooks?.beforeDelete) {
     try {
       await tableHooks.beforeDelete(auth, existingRow, requestHookCtx);
@@ -810,15 +818,17 @@ async function handleDelete(
   // Run afterDelete hook (fire-and-forget)
   if (tableHooks?.afterDelete) {
     const hook = tableHooks.afterDelete;
-    const backgroundHookCtx = buildHookCtx(resolved.connectionString, resolved.dbBlock.tables ?? {}, c.executionCtx);
+    const backgroundHookCtx = buildHookCtx(resolved.connectionString, c.env, c.executionCtx);
     backgroundHookCtx.waitUntil(
       Promise.resolve(hook(existingRow, backgroundHookCtx)).catch(() => {}),
     );
   }
 
   // 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 +954,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 +1047,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 +1092,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)`,
     );
   }