@edge-base/server 0.1.1

package/src/__tests__/websocket-pending.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { defineConfig } from '@edge-base/shared';
+import { OpenAPIHono, type HonoEnv } from '../lib/hono.js';
+import { setConfig } from '../lib/do-router.js';
+import {
+  acquirePendingWebSocketSlot,
+  getPendingWebSocketCount,
+  releasePendingWebSocketSlot,
+} from '../lib/websocket-pending.js';
+import { roomRoute } from '../routes/room.js';
+import type { Env } from '../types.js';
+
+interface MockKVStore {
+  data: Record<string, { value: string; options?: { expirationTtl?: number } }>;
+}
+
+function createMockKV(): KVNamespace & { _store: MockKVStore } {
+  const store: MockKVStore = { data: {} };
+
+  return {
+    get: async (key: string) => store.data[key]?.value ?? null,
+    put: async (key: string, value: string, options?: { expirationTtl?: number }) => {
+      store.data[key] = { value, options };
+    },
+    delete: async (key: string) => {
+      delete store.data[key];
+    },
+    list: async () => ({ keys: [], list_complete: true, cacheStatus: null }),
+    getWithMetadata: async () => ({ value: null, metadata: null, cacheStatus: null }),
+    _store: store,
+  } as unknown as KVNamespace & { _store: MockKVStore };
+}
+
+function createMockRoomEnv(
+  kv: KVNamespace & { _store: MockKVStore },
+  response = new Response(null, { status: 200 }),
+): Env {
+  const roomNamespace = {
+    idFromName: (name: string) => name as unknown as DurableObjectId,
+    get: () => ({
+      fetch: async () => response,
+    }),
+  } as unknown as DurableObjectNamespace;
+
+  return {
+    KV: kv,
+    ROOMS: roomNamespace,
+  } as unknown as Env;
+}
+
+function createRoomApp() {
+  const app = new OpenAPIHono<HonoEnv>();
+  app.route('/api/room', roomRoute);
+  return app;
+}
+
+describe('websocket pending connection counters', () => {
+  afterEach(() => {
+    setConfig({});
+  });
+
+  it('releases the room pending slot after proxying the upgrade request', async () => {
+    setConfig(defineConfig({
+      release: true,
+      rooms: {
+        game: {},
+      },
+    }));
+
+    const kv = createMockKV();
+    const app = createRoomApp();
+    const response = await app.request('/api/room?namespace=game&id=room-1', {
+      method: 'GET',
+      headers: {
+        Upgrade: 'websocket',
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockRoomEnv(kv));
+
+    expect(response.status).toBe(200);
+    expect(kv._store.data['ws:room:pending:127.0.0.1']).toBeUndefined();
+  });
+
+  it('restores the prior room pending count after a proxied request completes', async () => {
+    setConfig(defineConfig({
+      release: true,
+      rooms: {
+        game: {},
+      },
+    }));
+
+    const kv = createMockKV();
+    kv._store.data['ws:room:pending:127.0.0.1'] = { value: '4' };
+
+    const app = createRoomApp();
+    const response = await app.request('/api/room?namespace=game&id=room-1', {
+      method: 'GET',
+      headers: {
+        Upgrade: 'websocket',
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockRoomEnv(kv));
+
+    expect(response.status).toBe(200);
+    expect(kv._store.data['ws:room:pending:127.0.0.1']?.value).toBe('4');
+  });
+
+  it('reports room rate-limit diagnostics without consuming a slot', async () => {
+    setConfig(defineConfig({
+      release: true,
+      rooms: {
+        game: {},
+      },
+    }));
+
+    const kv = createMockKV();
+    kv._store.data['ws:room:pending:127.0.0.1'] = { value: '5' };
+
+    const app = createRoomApp();
+    const response = await app.request('/api/room/connect-check?namespace=game&id=room-1', {
+      method: 'GET',
+      headers: {
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockRoomEnv(kv));
+
+    expect(response.status).toBe(429);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      type: 'room_connect_rate_limited',
+      category: 'rate_limit',
+      pendingCount: 5,
+      maxPending: 5,
+    });
+    expect(kv._store.data['ws:room:pending:127.0.0.1']?.value).toBe('5');
+  });
+});
+
+describe('websocket pending helper functions', () => {
+  it('reads a missing pending counter as zero', async () => {
+    const kv = createMockKV();
+
+    await expect(getPendingWebSocketCount(kv, 'ws:pending:127.0.0.1')).resolves.toBe(0);
+  });
+
+  it('acquires slots until the max pending threshold is reached', async () => {
+    const kv = createMockKV();
+
+    await expect(acquirePendingWebSocketSlot(kv, 'ws:pending:127.0.0.1', 2, 30)).resolves.toBe(true);
+    await expect(acquirePendingWebSocketSlot(kv, 'ws:pending:127.0.0.1', 2, 30)).resolves.toBe(true);
+    await expect(acquirePendingWebSocketSlot(kv, 'ws:pending:127.0.0.1', 2, 30)).resolves.toBe(false);
+    expect(kv._store.data['ws:pending:127.0.0.1']?.value).toBe('2');
+  });
+
+  it('releases the final pending slot by deleting the key', async () => {
+    const kv = createMockKV();
+    kv._store.data['ws:pending:127.0.0.1'] = { value: '1' };
+
+    await releasePendingWebSocketSlot(kv, 'ws:pending:127.0.0.1', 30);
+
+    expect(kv._store.data['ws:pending:127.0.0.1']).toBeUndefined();
+  });
+});

package/src/_functions-registry.ts

@@ -0,0 +1,51 @@
+/**
+ * Auto-generated function registry.
+ * DO NOT EDIT — regenerated on each deploy/dev runtime.
+ * Repository fallback build: no project-local user functions are bundled.
+ */
+import type { AuthTrigger, FunctionDefinition, StorageTrigger } from '@edge-base/shared';
+import { registerFunction, registerMiddleware, rebuildCompiledRoutes } from './lib/functions.js';
+import { parseConfig } from './lib/do-router.js';
+import { RoomsDO } from './durable-objects/rooms-do.js';
+import config from './generated-config.js';
+
+export function initFunctionRegistry(): void {
+  const keepBundled = [config, registerMiddleware, RoomsDO];
+  void keepBundled;
+  const resolvedConfig = parseConfig();
+
+  // Plugin handlers are bundled via esbuild import graph (config imports from plugin packages),
+  // but registration must follow the already-resolved runtime config.
+  if (resolvedConfig?.plugins && Array.isArray(resolvedConfig.plugins)) {
+    for (const plugin of resolvedConfig.plugins) {
+      if (plugin.functions) {
+        for (const [funcName, funcDef] of Object.entries(plugin.functions)) {
+          registerFunction(`${plugin.name}/${funcName}`, funcDef as FunctionDefinition);
+        }
+      }
+      if (plugin.hooks) {
+        const STORAGE_EVENTS = new Set<StorageTrigger['event']>([
+          'beforeUpload',
+          'afterUpload',
+          'beforeDownload',
+          'beforeDelete',
+          'afterDelete',
+          'onMetadataUpdate',
+        ]);
+        for (const [event, hookFn] of Object.entries(plugin.hooks)) {
+          if (typeof hookFn === 'function') {
+            const trigger = STORAGE_EVENTS.has(event as StorageTrigger['event'])
+              ? { type: 'storage' as const, event: event as StorageTrigger['event'] }
+              : { type: 'auth' as const, event: event as AuthTrigger['event'] };
+            registerFunction(`__hook__/${plugin.name}/${event}`, {
+              trigger,
+              handler: hookFn,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  rebuildCompiledRoutes();
+}

package/src/bench-entry.ts

@@ -0,0 +1,9 @@
+/**
+ * Bench entrypoint — re-exports the main app + DO classes for vitest-pool-workers.
+ * This file is referenced by wrangler.bench.toml (main).
+ */
+export { default } from './index.js';
+export { DatabaseDO } from './durable-objects/database-do.js';
+export { AuthDO } from './durable-objects/auth-do.js';
+export { RoomsDO } from './durable-objects/rooms-do.js';
+export { DatabaseLiveDO } from './durable-objects/database-live-do.js';

package/src/cloudflare-test.d.ts

@@ -0,0 +1 @@
+declare module 'cloudflare:test';

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

@@ -0,0 +1,49 @@
+/**
+ * AuthDO — Empty shell (Phase 3: Auth DO → D1 migration)
+ *
+ * All auth operations now go through AUTH_DB D1 via auth-d1-service.ts.
+ * This class is kept for Cloudflare migration compatibility — existing
+ * DO instances won't be deleted, but all new requests return 410 Gone.
+ *
+ * The class export is required by wrangler.toml's [[durable_objects.bindings]].
+ * Add a migration tag to clear old DO storage on next deploy:
+ *   [[migrations]]
+ *   tag = "v3"
+ */
+import { DurableObject } from 'cloudflare:workers';
+
+interface AuthEnv {
+  AUTH_DB: D1Database;
+  KV: KVNamespace;
+  [key: string]: unknown;
+}
+
+export class AuthDO extends DurableObject<AuthEnv> {
+  /**
+   * All auth endpoints have been migrated to D1.
+   * Any remaining requests to this DO return 410 Gone.
+   */
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    // Backup dump — return empty data for legacy CLI backup compatibility
+    if (url.pathname === '/internal/backup/dump' || url.pathname === '/internal/backup/dump-users-public') {
+      return Response.json({ doName: request.headers.get('X-DO-Name') || 'unknown', tables: {}, users: [] });
+    }
+
+    // Backup restore — no-op for legacy CLI restore compatibility
+    if (url.pathname === '/internal/backup/restore') {
+      return Response.json({ ok: true, message: 'Auth DO migrated to D1. Restore skipped.' });
+    }
+
+    // Backup wipe — no-op
+    if (url.pathname === '/internal/backup/wipe') {
+      return Response.json({ ok: true, message: 'Auth DO migrated to D1. Wipe skipped.' });
+    }
+
+    return Response.json(
+      { code: 410, message: 'Auth DO has been migrated to D1. All auth operations use AUTH_DB directly.' },
+      { status: 410 },
+    );
+  }
+}