@edge-base/server 0.2.3 → 0.2.5

package/src/__tests__/table-hook-runtime.test.ts

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Env } from '../types.js';
+
+const {
+  ensureAuthSchemaMock,
+  resolveAuthDbMock,
+  sendToDatabaseLiveDOMock,
+  createPushProviderMock,
+  getDevicesForUserMock,
+  providerSendMock,
+} = vi.hoisted(() => ({
+  ensureAuthSchemaMock: vi.fn(),
+  resolveAuthDbMock: vi.fn(),
+  sendToDatabaseLiveDOMock: vi.fn(),
+  createPushProviderMock: vi.fn(),
+  getDevicesForUserMock: vi.fn(),
+  providerSendMock: vi.fn(),
+}));
+
+vi.mock('../lib/auth-d1.js', () => ({
+  ensureAuthSchema: ensureAuthSchemaMock,
+}));
+
+vi.mock('../lib/auth-db-adapter.js', () => ({
+  resolveAuthDb: resolveAuthDbMock,
+}));
+
+vi.mock('../lib/database-live-emitter.js', () => ({
+  sendToDatabaseLiveDO: sendToDatabaseLiveDOMock,
+}));
+
+vi.mock('../lib/push-provider.js', () => ({
+  createPushProvider: createPushProviderMock,
+}));
+
+vi.mock('../lib/push-token.js', () => ({
+  getDevicesForUser: getDevicesForUserMock,
+}));
+
+describe('buildTableHookRuntimeServices', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    ensureAuthSchemaMock.mockReset().mockResolvedValue(undefined);
+    resolveAuthDbMock.mockReset().mockReturnValue({ kind: 'auth-db' });
+    sendToDatabaseLiveDOMock.mockReset().mockResolvedValue(undefined);
+    createPushProviderMock.mockReset().mockReturnValue({ send: providerSendMock });
+    getDevicesForUserMock.mockReset().mockResolvedValue([]);
+    providerSendMock.mockReset().mockResolvedValue({ success: true });
+  });
+
+  it('broadcasts hook events through DatabaseLiveDO', async () => {
+    const { buildTableHookRuntimeServices } = await import('../lib/table-hook-runtime.js');
+    const env = {
+      DATABASE_LIVE: {} as DurableObjectNamespace,
+    } as Env;
+
+    const services = buildTableHookRuntimeServices({} as never, env);
+    await services.databaseLive.broadcast('posts', 'created', { id: 'post-1' });
+
+    expect(sendToDatabaseLiveDOMock).toHaveBeenCalledWith(
+      env,
+      {
+        channel: 'posts',
+        event: 'created',
+        payload: { id: 'post-1' },
+      },
+      '/internal/broadcast',
+    );
+  });
+
+  it('sends push notifications using auth-backed device lookups when available', async () => {
+    const { buildTableHookRuntimeServices } = await import('../lib/table-hook-runtime.js');
+    const authDb = { kind: 'auth-db' };
+    resolveAuthDbMock.mockReturnValue(authDb);
+    getDevicesForUserMock.mockResolvedValue([
+      { token: 'token-1', platform: 'ios' },
+      { token: 'token-2', platform: 'android' },
+    ]);
+    const env = {
+      KV: {} as KVNamespace,
+      AUTH_DB: {} as D1Database,
+    } as Env;
+
+    const pushConfig = {
+      fcm: {
+        projectId: 'demo-project',
+        serviceAccount: '{"client_email":"demo@example.com"}',
+      },
+    };
+    const services = buildTableHookRuntimeServices({ push: pushConfig } as never, env);
+    await services.push.send('user-123', { title: 'Hello', body: 'World' });
+
+    expect(resolveAuthDbMock).toHaveBeenCalledWith(env);
+    expect(ensureAuthSchemaMock).toHaveBeenCalledWith(authDb);
+    expect(createPushProviderMock).toHaveBeenCalledWith(pushConfig, env);
+    expect(getDevicesForUserMock).toHaveBeenCalledWith({ kv: env.KV, authDb }, 'user-123');
+    expect(providerSendMock).toHaveBeenCalledTimes(2);
+    expect(providerSendMock).toHaveBeenNthCalledWith(1, {
+      token: 'token-1',
+      platform: 'ios',
+      payload: { title: 'Hello', body: 'World' },
+    });
+    expect(providerSendMock).toHaveBeenNthCalledWith(2, {
+      token: 'token-2',
+      platform: 'android',
+      payload: { title: 'Hello', body: 'World' },
+    });
+  });
+
+  it('falls back to KV-only token lookups when auth db resolution fails', async () => {
+    const { buildTableHookRuntimeServices } = await import('../lib/table-hook-runtime.js');
+    resolveAuthDbMock.mockImplementation(() => {
+      throw new Error('missing auth db');
+    });
+    getDevicesForUserMock.mockResolvedValue([{ token: 'token-1', platform: 'web' }]);
+    const env = {
+      KV: {} as KVNamespace,
+    } as Env;
+
+    const pushConfig = {
+      fcm: {
+        projectId: 'demo-project',
+        serviceAccount: '{"client_email":"demo@example.com"}',
+      },
+    };
+    const services = buildTableHookRuntimeServices({ push: pushConfig } as never, env);
+    await services.push.send('user-123', { body: 'Fallback works' });
+
+    expect(ensureAuthSchemaMock).not.toHaveBeenCalled();
+    expect(getDevicesForUserMock).toHaveBeenCalledWith(env.KV, 'user-123');
+    expect(providerSendMock).toHaveBeenCalledWith({
+      token: 'token-1',
+      platform: 'web',
+      payload: { body: 'Fallback works' },
+    });
+  });
+});

package/src/durable-objects/database-do.ts

@@ -54,15 +54,13 @@ import {
   getRegisteredFunctions,
   buildFunctionContext,
 } from '../lib/functions.js';
-import { parseDbDoName, parseConfig as getGlobalConfig } from '../lib/do-router.js';
+import { parseDbDoName, parseConfig as getGlobalConfig, isDynamicDbBlock } from '../lib/do-router.js';
 import { parseDuration } from '../lib/jwt.js';
-import { createPushProvider } from '../lib/push-provider.js';
-import { getDevicesForUser } from '../lib/push-token.js';
-import { ensureAuthSchema } from '../lib/auth-d1.js';
-import { resolveAuthDb, type AuthDb } from '../lib/auth-db-adapter.js';
 import { buildDbLiveChannel, DATABASE_LIVE_HUB_DO_NAME } from '../lib/database-live-emitter.js';
 import { resolveRootServiceKey } from '../lib/service-key.js';
 import { resolveDbLiveBatchThreshold } from '../lib/database-live-config.js';
+import { buildTableHookRuntimeServices } from '../lib/table-hook-runtime.js';
+import { ensureServerStartup } from '../lib/runtime-startup.js';
 import type { Env } from '../types.js';
 
 // ─── Types ───
@@ -83,6 +81,7 @@ export class DatabaseDO extends DurableObject<DOEnv> {
   private config: EdgeBaseConfig;
   private initialized = false;
   private doName = '';
+  private runtimeReadyPromise: Promise<void> | null = null;
 
   constructor(ctx: DurableObjectState, env: DOEnv) {
     super(ctx, env);
@@ -95,6 +94,7 @@ export class DatabaseDO extends DurableObject<DOEnv> {
   }
 
   async fetch(request: Request): Promise<Response> {
+    await this.ensureRuntimeReady();
     // Determine DO name from header or URL
     const doNameHeader = request.headers.get('X-DO-Name');
 
@@ -104,8 +104,36 @@ export class DatabaseDO extends DurableObject<DOEnv> {
     if (!this.initialized) {
       // §36: Newly created DO must be authorized before initialization.
       // If X-DO-Create-Authorized header is absent, signal Worker to evaluate canCreate.
-      // Shared/static DOs (doName === 'shared' or system) skip this gate.
-      const isStaticDO = !this.doName || this.doName === 'shared' || this.doName.startsWith('_');
+      // Single-instance DB blocks and internal/system DOs skip this gate.
+      const parsedDoName = this.doName ? parseDbDoName(this.doName) : null;
+      const dbBlock = parsedDoName ? this.config.databases?.[parsedDoName.namespace] : undefined;
+      const dynamicDbBlock = isDynamicDbBlock(dbBlock);
+      if (parsedDoName && dbBlock) {
+        if (dynamicDbBlock && !parsedDoName.id) {
+          return Response.json(
+            {
+              code: 400,
+              message: `instanceId is required for dynamic namespace '${parsedDoName.namespace}'`,
+              error: 'INVALID_DB_INSTANCE_ID',
+            },
+            { status: 400 },
+          );
+        }
+        if (!dynamicDbBlock && parsedDoName.id) {
+          return Response.json(
+            {
+              code: 400,
+              message: `instanceId is not allowed for single-instance namespace '${parsedDoName.namespace}'`,
+              error: 'INVALID_DB_INSTANCE_ID',
+            },
+            { status: 400 },
+          );
+        }
+      }
+      const isStaticDO =
+        !this.doName
+        || this.doName.startsWith('_')
+        || (!!dbBlock && !dynamicDbBlock && !parsedDoName?.id);
       if (!isStaticDO && !request.headers.get('X-DO-Create-Authorized')) {
         // Check if _meta table already exists (i.e., DO was previously initialized)
         let alreadyExists = false;
@@ -118,9 +146,8 @@ export class DatabaseDO extends DurableObject<DOEnv> {
 
         if (!alreadyExists) {
           // Signal Worker: this DO needs canCreate evaluation before init
-          const parsed = this.doName ? parseDbDoName(this.doName) : null;
           return Response.json(
-            { needsCreate: true, namespace: parsed?.namespace ?? 'shared', id: parsed?.id },
+            { needsCreate: true, namespace: parsedDoName?.namespace ?? 'shared', id: parsedDoName?.id },
             { status: 201 },
           );
         }
@@ -173,6 +200,8 @@ export class DatabaseDO extends DurableObject<DOEnv> {
    * db.get/list/exists use local SQL; databaseLive.broadcast uses emitDbLiveEvent.
    */
   private buildHookCtx(_table: string): HookCtx {
+    const runtimeServices = buildTableHookRuntimeServices(this.config, this.env as unknown as Env);
+
     return {
       db: {
         get: (tbl: string, id: string) => {
@@ -201,42 +230,7 @@ export class DatabaseDO extends DurableObject<DOEnv> {
           return Promise.resolve(rows.length > 0);
         },
       },
-      databaseLive: {
-        broadcast: (channel: string, event: string, data: unknown) => {
-          return this.sendBroadcastToDatabaseLiveDO(
-            channel,
-            { channel, event, payload: data ?? {} },
-          );
-        },
-      },
-      push: {
-        // Push from hooks — direct FCM via push-provider + KV device tokens
-        send: async (userId: string, payload: { title?: string; body: string }) => {
-          // Fire-and-forget — hooks are non-critical side effects
-          try {
-            if (!this.env.KV) return;
-            const provider = createPushProvider(this.config.push, this.env as unknown as Env);
-            if (!provider) return;
-            let tokenStore: KVNamespace | { kv: KVNamespace; authDb?: AuthDb | null } = this.env.KV;
-            try {
-              const authDb = resolveAuthDb(this.env as unknown as Record<string, unknown>);
-              await ensureAuthSchema(authDb);
-              tokenStore = { kv: this.env.KV, authDb };
-            } catch {
-              tokenStore = this.env.KV;
-            }
-            const devices = await getDevicesForUser(tokenStore, userId);
-            if (devices.length === 0) return;
-            await Promise.allSettled(
-              devices.map((device) =>
-                provider.send({ token: device.token, platform: device.platform, payload }),
-              ),
-            );
-          } catch {
-            /* best-effort */
-          }
-        },
-      },
+      ...runtimeServices,
       waitUntil: (p: Promise<unknown>) => this.ctx.waitUntil(p),
     };
   }
@@ -2000,6 +1994,17 @@ export class DatabaseDO extends DurableObject<DOEnv> {
     return getGlobalConfig(env);
   }
 
+  private async ensureRuntimeReady(): Promise<void> {
+    if (!this.runtimeReadyPromise) {
+      this.runtimeReadyPromise = (async () => {
+        await ensureServerStartup();
+        this.config = this.parseConfig(this.env);
+      })();
+    }
+
+    await this.runtimeReadyPromise;
+  }
+
   // ─── Database Live Event Emission ───
 
   /**

package/src/durable-objects/database-live-do.ts

@@ -7,6 +7,7 @@ import { verifyAccessToken } from '../lib/jwt.js';
 import { parseConfig as getGlobalConfig } from '../lib/do-router.js';
 import { isDbLiveChannel } from '../lib/database-live-emitter.js';
 import { resolveDbLiveAuthTimeoutMs } from '../lib/database-live-config.js';
+import { ensureServerStartup } from '../lib/runtime-startup.js';
 
 interface DOEnv {
   JWT_USER_SECRET?: string;
@@ -142,6 +143,7 @@ export class DatabaseLiveDO extends DurableObject<DOEnv> {
   private pendingAuth = new Map<string, ReturnType<typeof setTimeout>>();
   private metaCache = new Map<WebSocket, WSMeta>();
   private recentDeliveryIds = new Map<string, number>();
+  private runtimeReadyPromise: Promise<void> | null = null;
 
   constructor(ctx: DurableObjectState, env: DOEnv) {
     super(ctx, env);
@@ -149,6 +151,7 @@ export class DatabaseLiveDO extends DurableObject<DOEnv> {
   }
 
   async fetch(request: Request): Promise<Response> {
+    await this.ensureRuntimeReady();
     const url = new URL(request.url);
 
     if (url.pathname === '/internal/event') {
@@ -218,6 +221,7 @@ export class DatabaseLiveDO extends DurableObject<DOEnv> {
   }
 
   async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+    await this.ensureRuntimeReady();
     if (typeof message !== 'string') return;
 
     let msg: Record<string, unknown>;
@@ -922,6 +926,17 @@ export class DatabaseLiveDO extends DurableObject<DOEnv> {
     if (parts.length >= 5) return parts[3];
     return null;
   }
+
+  private async ensureRuntimeReady(): Promise<void> {
+    if (!this.runtimeReadyPromise) {
+      this.runtimeReadyPromise = (async () => {
+        await ensureServerStartup();
+        this.config = getGlobalConfig(this.env);
+      })();
+    }
+
+    await this.runtimeReadyPromise;
+  }
 }
 
 export function evaluateDatabaseLiveFilters(