@edge-base/server 0.1.1

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@edge-base/server",
+    "version": "0.1.1",
+    "description": "EdgeBase runtime assets consumed by the EdgeBase CLI",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/edge-base/edgebase.git",
+        "directory": "packages/server"
+    },
+    "homepage": "https://edgebase.fun",
+    "bugs": "https://github.com/edge-base/edgebase/issues",
+    "keywords": [
+        "edgebase",
+        "runtime",
+        "server",
+        "cloudflare-workers"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "type": "module",
+    "main": "./src/index.ts",
+    "files": [
+        "src",
+        "admin-build",
+        "openapi.json"
+    ],
+    "scripts": {
+        "build": "tsc --noEmit",
+        "lint": "eslint src/ --max-warnings 0",
+        "test": "vitest run --config vitest.unit.config.ts",
+        "test:integration": "./scripts/run-integration-shards.sh",
+        "bench": "vitest run --config vitest.bench.config.ts",
+        "dev": "./scripts/dev.sh",
+        "dev:raw": "wrangler dev",
+        "test:e2e": "vitest run --config vitest.e2e.config.ts",
+        "prepack": "pnpm --dir ../admin build && pnpm run build && node ./scripts/copy-admin-build.mjs"
+    },
+    "dependencies": {
+        "@edge-base/shared": "workspace:*",
+        "@hono/zod-openapi": "^1.2.2",
+        "@simplewebauthn/server": "^10",
+        "bcryptjs": "^3.0.3",
+        "hono": "^4.12.5",
+        "jose": "^6.0.0",
+        "pg": "^8.16.3",
+        "zod": "^4.3.6"
+    },
+    "devDependencies": {
+        "@cloudflare/vitest-pool-workers": "^0.8.71",
+        "@cloudflare/workers-types": "^4.20260305.1",
+        "@stryker-mutator/core": "^8.7.0",
+        "@stryker-mutator/typescript-checker": "^8.7.0",
+        "@stryker-mutator/vitest-runner": "^8.7.0",
+        "@types/bcryptjs": "^3.0.0",
+        "@types/pg": "^8.11.0",
+        "@types/ws": "^8.18.1",
+        "@vitest/coverage-v8": "^3.2.4",
+        "fast-check": "^4.5.3",
+        "typescript": "^5.7.0",
+        "vitest": "^3.0.0",
+        "wrangler": "^4.70.0",
+        "ws": "^8.19.0"
+    }
+}

package/src/__tests__/admin-assets.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createAdminAssetRequest,
+  createHarnessAssetRequest,
+  resolveAdminAssetPath,
+  resolveHarnessAssetPath,
+} from '../lib/admin-assets.js';
+
+describe('admin asset path resolution', () => {
+  it('serves index for the admin root', () => {
+    expect(resolveAdminAssetPath('/admin')).toBe('/');
+    expect(resolveAdminAssetPath('/admin/')).toBe('/');
+  });
+
+  it('strips the /admin prefix for built assets', () => {
+    expect(resolveAdminAssetPath('/admin/_app/version.json')).toBe('/_app/version.json');
+    expect(resolveAdminAssetPath('/admin/favicon.png')).toBe('/favicon.png');
+  });
+
+  it('falls back to index for client-side admin routes', () => {
+    expect(resolveAdminAssetPath('/admin/login')).toBe('/');
+    expect(resolveAdminAssetPath('/admin/database/tables')).toBe('/');
+  });
+
+  it('rewrites requests without dropping the query string', () => {
+    const request = new Request('http://localhost:8787/admin/login?next=%2Fadmin%2Fdatabase');
+    const rewritten = createAdminAssetRequest(request);
+    const url = new URL(rewritten.url);
+
+    expect(url.pathname).toBe('/');
+    expect(url.search).toBe('?next=%2Fadmin%2Fdatabase');
+  });
+});
+
+describe('harness asset path resolution', () => {
+  it('serves index for the harness root and client-side routes', () => {
+    expect(resolveHarnessAssetPath('/harness')).toBe('/harness.html');
+    expect(resolveHarnessAssetPath('/harness/')).toBe('/harness.html');
+    expect(resolveHarnessAssetPath('/harness/scenarios/registered')).toBe('/harness.html');
+  });
+
+  it('preserves explicit asset paths under /harness', () => {
+    expect(resolveHarnessAssetPath('/harness/assets/main.js')).toBe('/harness/assets/main.js');
+    expect(resolveHarnessAssetPath('/harness/favicon.svg')).toBe('/harness/favicon.svg');
+  });
+
+  it('rewrites harness requests without dropping the query string', () => {
+    const request = new Request('http://localhost:8787/harness/scenarios?mode=golden');
+    const rewritten = createHarnessAssetRequest(request);
+    const url = new URL(rewritten.url);
+
+    expect(url.pathname).toBe('/harness.html');
+    expect(url.search).toBe('?mode=golden');
+  });
+});

package/src/__tests__/admin-data-routes.test.ts

@@ -0,0 +1,488 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { OpenAPIHono, type HonoEnv } from '../lib/hono.js';
+import { adminRoute } from '../routes/admin.js';
+import { setConfig } from '../lib/do-router.js';
+import { defineConfig } from '@edge-base/shared';
+import type { Env } from '../types.js';
+
+function createApp() {
+  const app = new OpenAPIHono<HonoEnv>();
+  app.route('/admin/api', adminRoute);
+  return app;
+}
+
+function createConfig(databases: NonNullable<ReturnType<typeof defineConfig>['databases']>) {
+  return defineConfig({
+    databases,
+    serviceKeys: {
+      keys: [
+        {
+          kid: 'root',
+          tier: 'root',
+          scopes: ['*'],
+          secretSource: 'inline',
+          inlineSecret: 'sk-root',
+        },
+      ],
+    },
+  });
+}
+
+describe('admin data routes', () => {
+  afterEach(() => {
+    setConfig({});
+  });
+
+  it('reports effective providers and dynamic metadata in admin schema', async () => {
+    setConfig(
+      createConfig({
+        shared: {
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+        workspace: {
+          instance: true,
+          admin: {
+            instances: {
+              source: 'manual',
+              targetLabel: 'Workspace',
+              helperText: 'Enter a workspace ID.',
+            },
+          },
+          tables: {
+            tasks: { schema: { done: { type: 'boolean' } } },
+          },
+        },
+        analytics: {
+          provider: 'postgres',
+          tables: {
+            events: { schema: { name: { type: 'string' } } },
+          },
+        },
+        reporting: {
+          provider: 'neon',
+          tables: {
+            snapshots: { schema: { label: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/schema',
+      {
+        headers: {
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+      },
+      {} as Env,
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      namespaces: {
+        shared: {
+          provider: 'd1',
+          dynamic: false,
+        },
+        workspace: {
+          provider: 'do',
+          dynamic: true,
+          instanceDiscovery: {
+            source: 'manual',
+            targetLabel: 'Workspace',
+            helperText: 'Enter a workspace ID.',
+          },
+        },
+        analytics: {
+          provider: 'postgres',
+          dynamic: false,
+        },
+        reporting: {
+          provider: 'neon',
+          dynamic: false,
+        },
+      },
+      schema: {
+        posts: {
+          namespace: 'shared',
+          provider: 'd1',
+          dynamic: false,
+        },
+        tasks: {
+          namespace: 'workspace',
+          provider: 'do',
+          dynamic: true,
+          instanceDiscovery: {
+            source: 'manual',
+            targetLabel: 'Workspace',
+            helperText: 'Enter a workspace ID.',
+          },
+        },
+        events: {
+          namespace: 'analytics',
+          provider: 'postgres',
+          dynamic: false,
+        },
+        snapshots: {
+          namespace: 'reporting',
+          provider: 'neon',
+          dynamic: false,
+        },
+      },
+    });
+  });
+
+  it('rejects dynamic record browsing without an instanceId', async () => {
+    setConfig(
+      createConfig({
+        workspace: {
+          instance: true,
+          tables: {
+            members: { schema: { userId: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/tables/members/records',
+      {
+        headers: {
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+      },
+      {} as Env,
+    );
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toMatchObject({
+      code: 400,
+      message: "instanceId is required for dynamic namespace 'workspace'",
+    });
+  });
+
+  it('routes dynamic record browsing to the scoped DO when instanceId is provided', async () => {
+    setConfig(
+      createConfig({
+        workspace: {
+          instance: true,
+          tables: {
+            members: { schema: { userId: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const stub = {
+      fetch: vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({ rows: [{ id: '1' }], total: 1 }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    };
+    const env = {
+      DATABASE: {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn().mockReturnValue(stub),
+      },
+    } as unknown as Env;
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/tables/members/records?instanceId=ws-1&limit=1',
+      {
+        headers: {
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+      },
+      env,
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      rows: [{ id: '1' }],
+      total: 1,
+    });
+
+    expect(stub.fetch).toHaveBeenCalledTimes(1);
+    const forwardedInit = stub.fetch.mock.calls[0]?.[1] as RequestInit;
+    const headers = new Headers(forwardedInit.headers);
+    expect(headers.get('X-DO-Name')).toBe('workspace:ws-1');
+  });
+
+  it('uses D1 run() for admin SQL mutations so table rename actually executes', async () => {
+    setConfig(
+      createConfig({
+        shared: {
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const stmt: {
+      bind: ReturnType<typeof vi.fn>;
+      all: ReturnType<typeof vi.fn>;
+      run: ReturnType<typeof vi.fn>;
+    } = {
+      bind: vi.fn(() => stmt),
+      all: vi.fn().mockResolvedValue({ results: [] }),
+      run: vi.fn().mockResolvedValue({ meta: { changes: 0 } }),
+    };
+    const env = {
+      DB_D1_SHARED: {
+        prepare: vi.fn(() => stmt),
+      },
+    } as unknown as Env;
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/sql',
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+        body: JSON.stringify({
+          namespace: 'shared',
+          sql: 'ALTER TABLE "posts" RENAME TO "articles"',
+        }),
+      },
+      env,
+    );
+
+    expect(response.status).toBe(200);
+    expect((env as unknown as { DB_D1_SHARED: { prepare: ReturnType<typeof vi.fn> } }).DB_D1_SHARED.prepare).toHaveBeenCalledWith(
+      'ALTER TABLE "posts" RENAME TO "articles"',
+    );
+    expect(stmt.run).toHaveBeenCalledTimes(1);
+    expect(stmt.all).not.toHaveBeenCalled();
+  });
+
+  it('proxies namespace dump and restore through admin backup routes for D1-backed blocks', async () => {
+    setConfig(
+      createConfig({
+        shared: {
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const selectAll = vi.fn()
+      .mockResolvedValueOnce({ results: [{ id: '1', title: 'Hello' }] })
+      .mockResolvedValueOnce({ results: [{ key: 'schemaHash:posts', value: 'abc' }] });
+    const selectFirst = vi.fn().mockResolvedValue(null);
+    const run = vi.fn().mockResolvedValue({ meta: { changes: 0 } });
+
+    const prepare = vi.fn((sql: string) => {
+      const stmt = {
+        bind: vi.fn(() => stmt),
+        all: vi.fn(() => {
+          if (sql.startsWith('SELECT * FROM')) {
+            return selectAll();
+          }
+          return Promise.resolve({ results: [] });
+        }),
+        first: vi.fn(() => selectFirst()),
+        run: vi.fn(() => run()),
+      };
+      return stmt;
+    });
+
+    const env = {
+      DB_D1_SHARED: {
+        prepare,
+        batch: vi.fn().mockResolvedValue([]),
+      },
+    } as unknown as Env;
+
+    const app = createApp();
+
+    const dumpResponse = await app.request(
+      '/admin/api/data/backup/dump-data',
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+        body: JSON.stringify({ namespace: 'shared' }),
+      },
+      env,
+    );
+
+    expect(dumpResponse.status).toBe(200);
+    await expect(dumpResponse.json()).resolves.toMatchObject({
+      namespace: 'shared',
+      tables: {
+        posts: [{ id: '1', title: 'Hello' }],
+        _meta: [{ key: 'schemaHash:posts', value: 'abc' }],
+      },
+    });
+
+    const restoreResponse = await app.request(
+      '/admin/api/data/backup/restore-data',
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+        body: JSON.stringify({
+          namespace: 'shared',
+          tables: {
+            posts: [{ id: '1', title: 'Hello' }],
+            _meta: [{ key: 'schemaHash:posts', value: 'abc' }],
+          },
+        }),
+      },
+      env,
+    );
+
+    expect(restoreResponse.status).toBe(200);
+    await expect(restoreResponse.json()).resolves.toMatchObject({
+      ok: true,
+      namespace: 'shared',
+      restored: 2,
+    });
+
+    expect((env as unknown as { DB_D1_SHARED: { batch: ReturnType<typeof vi.fn> } }).DB_D1_SHARED.batch).toHaveBeenCalled();
+  });
+
+  it('lists table-backed instance suggestions for dynamic namespaces', async () => {
+    setConfig(
+      createConfig({
+        shared: {
+          tables: {
+            workspaces: {
+              schema: {
+                name: { type: 'string' },
+                slug: { type: 'string' },
+              },
+            },
+          },
+        },
+        workspace: {
+          instance: true,
+          admin: {
+            instances: {
+              source: 'table',
+              targetLabel: 'Workspace',
+              namespace: 'shared',
+              table: 'workspaces',
+              labelField: 'name',
+              searchFields: ['name', 'slug'],
+              helperText: 'Pick a workspace.',
+            },
+          },
+          tables: {
+            members: { schema: { userId: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const stmt: {
+      bind: ReturnType<typeof vi.fn>;
+      all: ReturnType<typeof vi.fn>;
+    } = {
+      bind: vi.fn(() => stmt),
+      all: vi.fn().mockResolvedValue({
+        results: [
+          { __edgebase_id: 'ws_1', __edgebase_label: 'Acme' },
+          { __edgebase_id: 'ws_2', __edgebase_label: 'Beta' },
+        ],
+      }),
+    };
+    const env = {
+      DB_D1_SHARED: {
+        prepare: vi.fn(() => stmt),
+      },
+    } as unknown as Env;
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/namespaces/workspace/instances?q=ac&limit=5',
+      {
+        headers: {
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+      },
+      env,
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      discovery: {
+        source: 'table',
+        targetLabel: 'Workspace',
+        helperText: 'Pick a workspace.',
+      },
+      items: [
+        { id: 'ws_1', label: 'Acme' },
+        { id: 'ws_2', label: 'Beta' },
+      ],
+    });
+
+    expect((env as unknown as { DB_D1_SHARED: { prepare: ReturnType<typeof vi.fn> } }).DB_D1_SHARED.prepare).toHaveBeenCalledWith(
+      expect.stringContaining('FROM "workspaces"'),
+    );
+  });
+
+  it('lists function-backed instance suggestions for dynamic namespaces', async () => {
+    setConfig(
+      createConfig({
+        workspace: {
+          instance: true,
+          admin: {
+            instances: {
+              source: 'function',
+              targetLabel: 'Workspace',
+              helperText: 'Recent workspaces',
+              resolve: ({ query, limit }) => [
+                { id: 'ws_recent', label: `Recent ${query}` },
+                { id: 'ws_recent', label: 'Duplicate should be dropped' },
+                { id: 'bad:id', label: 'Invalid' },
+              ].slice(0, limit),
+            },
+          },
+          tables: {
+            members: { schema: { userId: { type: 'string' } } },
+          },
+        },
+      }),
+    );
+
+    const app = createApp();
+    const response = await app.request(
+      '/admin/api/data/namespaces/workspace/instances?q=team&limit=3',
+      {
+        headers: {
+          'X-EdgeBase-Service-Key': 'sk-root',
+        },
+      },
+      {} as Env,
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      discovery: {
+        source: 'function',
+        targetLabel: 'Workspace',
+        helperText: 'Recent workspaces',
+      },
+      items: [
+        { id: 'ws_recent', label: 'Recent team' },
+      ],
+    });
+  });
+});

package/src/__tests__/admin-db-target.test.ts

@@ -0,0 +1,103 @@
+import { defineConfig } from '@edge-base/shared';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  executeAdminDbQuery,
+  resolveAdminInstanceOptions,
+  serializeAdminInstanceDiscovery,
+} from '../lib/admin-db-target.js';
+
+describe('admin db target helpers', () => {
+  it('serializes manual discovery metadata with fallback defaults', () => {
+    expect(
+      serializeAdminInstanceDiscovery(undefined, { fallbackManual: true }),
+    ).toEqual({
+      source: 'manual',
+      targetLabel: 'Target',
+      placeholder: 'Target ID',
+      helperText: 'Enter a target ID to browse records and run queries for this table.',
+    });
+
+    expect(serializeAdminInstanceDiscovery({
+      source: 'manual',
+      targetLabel: 'Workspace',
+      placeholder: 'Workspace ID',
+      helperText: 'Pick a workspace.',
+    })).toEqual({
+      source: 'manual',
+      targetLabel: 'Workspace',
+      placeholder: 'Workspace ID',
+      helperText: 'Pick a workspace.',
+    });
+  });
+
+  it('executes admin SQL against D1-backed static namespaces', async () => {
+    const all = vi.fn().mockResolvedValue({
+      results: [{ id: 'row-1', label: 'Acme' }],
+    });
+    const prepare = vi.fn(() => ({ all }));
+
+    const result = await executeAdminDbQuery({
+      env: {
+        DB_D1_SHARED: {
+          prepare,
+        },
+      } as any,
+      config: defineConfig({
+        databases: {
+          shared: {
+            provider: 'd1',
+            tables: {
+              posts: {},
+            },
+          },
+        },
+      }),
+      namespace: 'shared',
+      sql: 'SELECT id, label FROM posts',
+    });
+
+    expect(prepare).toHaveBeenCalledWith('SELECT id, label FROM posts');
+    expect(result).toEqual({
+      columns: ['id', 'label'],
+      rows: [{ id: 'row-1', label: 'Acme' }],
+      rowCount: 1,
+    });
+  });
+
+  it('returns empty suggestions for manual dynamic instance discovery', async () => {
+    const result = await resolveAdminInstanceOptions({
+      env: {} as any,
+      config: defineConfig({
+        databases: {
+          workspace: {
+            instance: true,
+            admin: {
+              instances: {
+                source: 'manual',
+                targetLabel: 'Workspace',
+                placeholder: 'Workspace ID',
+                helperText: 'Enter a workspace ID.',
+              },
+            },
+            tables: {
+              members: {},
+            },
+          },
+        },
+      }),
+      namespace: 'workspace',
+      query: 'acme',
+      limit: 20,
+    });
+
+    expect(result).toEqual({
+      discovery: {
+        source: 'manual',
+        targetLabel: 'Workspace',
+        placeholder: 'Workspace ID',
+        helperText: 'Enter a workspace ID.',
+      },
+      items: [],
+    });
+  });
+});