@edge-base/server 0.2.2 → 0.2.4

package/src/__tests__/database-live-route.test.ts

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { OpenAPIHono, type HonoEnv } from '../lib/hono.js';
 import { setConfig } from '../lib/do-router.js';
 import { databaseLiveRoute } from '../routes/database-live.js';
+import { defineConfig } from '@edge-base/shared';
 import type { Env } from '../types.js';
 
 interface MockKVStore {
@@ -52,6 +53,16 @@ describe('database live subscription route', () => {
   });
 
   it('reports connect-check readiness for explicit database params', async () => {
+    setConfig(defineConfig({
+      databases: {
+        shared: {
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      },
+    }));
+
     const kv = createMockKV();
     const app = createApp();
 
@@ -90,7 +101,78 @@ describe('database live subscription route', () => {
     });
   });
 
+  it('rejects structured targets that omit instanceId for dynamic namespaces', async () => {
+    setConfig(defineConfig({
+      databases: {
+        workspace: {
+          instance: true,
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      },
+    }));
+
+    const kv = createMockKV();
+    const app = createApp();
+
+    const response = await app.request('/api/db/connect-check?namespace=workspace&table=posts', {
+      method: 'GET',
+      headers: {
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockEnv(kv));
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      type: 'db_connect_invalid_request',
+      message: "instanceId is required for dynamic namespace 'workspace'",
+    });
+  });
+
+  it('rejects legacy channels that target dynamic namespaces without an instanceId', async () => {
+    setConfig(defineConfig({
+      databases: {
+        workspace: {
+          instance: true,
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      },
+    }));
+
+    const kv = createMockKV();
+    const app = createApp();
+
+    const response = await app.request('/api/db/connect-check?channel=dblive:workspace:posts', {
+      method: 'GET',
+      headers: {
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockEnv(kv));
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      type: 'db_connect_invalid_request',
+      message: "instanceId is required for dynamic namespace 'workspace'",
+    });
+  });
+
   it('proxies websocket subscribe requests through the database-owned path and releases pending slots', async () => {
+    setConfig(defineConfig({
+      databases: {
+        workspace: {
+          instance: true,
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      },
+    }));
+
     const kv = createMockKV();
     const app = createApp();
     let forwardedUrl = '';

package/src/__tests__/do-router.test.ts

@@ -18,8 +18,12 @@ import {
   parseConfig,
   getTablesInNamespace,
   findTableNamespace,
+  formatDbTargetValidationIssue,
   callDO,
   callDOByHexId,
+  isDynamicDbBlock,
+  normalizeDbInstanceId,
+  resolveDbTarget,
   shouldRouteToD1,
   getD1BindingName,
 } from '../lib/do-router.js';
@@ -634,6 +638,118 @@ describe('callDOByHexId', () => {
 
 // ─── J. shouldRouteToD1 ───────────────────────────────────────────────────────
 
+describe('isDynamicDbBlock', () => {
+  it('returns false for undefined db blocks', () => {
+    expect(isDynamicDbBlock()).toBe(false);
+  });
+
+  it('returns false for single-instance db blocks without create/access semantics', () => {
+    expect(isDynamicDbBlock({ tables: { posts: {} } } as any)).toBe(false);
+  });
+
+  it('returns true for db blocks with instance routing', () => {
+    expect(isDynamicDbBlock({ instance: true, tables: {} } as any)).toBe(true);
+  });
+
+  it('returns true for db blocks with canCreate rules', () => {
+    expect(isDynamicDbBlock({
+      access: {
+        canCreate: () => true,
+      },
+      tables: {},
+    } as any)).toBe(true);
+  });
+
+  it('returns true for db blocks with access rules', () => {
+    expect(isDynamicDbBlock({
+      access: {
+        access: () => true,
+      },
+      tables: {},
+    } as any)).toBe(true);
+  });
+});
+
+describe('normalizeDbInstanceId', () => {
+  it('preserves non-empty ids verbatim', () => {
+    expect(normalizeDbInstanceId('  ws-1  ')).toBe('  ws-1  ');
+  });
+
+  it('keeps blank string inputs distinguishable from missing ids', () => {
+    expect(normalizeDbInstanceId('   ')).toBe('   ');
+    expect(normalizeDbInstanceId(undefined)).toBeUndefined();
+    expect(normalizeDbInstanceId(null)).toBeUndefined();
+  });
+});
+
+describe('resolveDbTarget', () => {
+  const config = {
+    databases: {
+      shared: { tables: { posts: {} } },
+      workspace: { instance: true, tables: { members: {} } },
+    },
+  } as any;
+
+  it('resolves single-instance namespaces without instance ids', () => {
+    expect(resolveDbTarget(config, 'shared', undefined)).toEqual({
+      ok: true,
+      value: {
+        namespace: 'shared',
+        instanceId: undefined,
+        dbBlock: config.databases.shared,
+        dynamic: false,
+      },
+    });
+  });
+
+  it('rejects instance ids on single-instance namespaces', () => {
+    const result = resolveDbTarget(config, 'shared', 'shadow');
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.issue).toBe('instance_id_not_allowed');
+    expect(formatDbTargetValidationIssue(result.issue, 'shared')).toBe(
+      "instanceId is not allowed for single-instance namespace 'shared'",
+    );
+  });
+
+  it('requires instance ids on dynamic namespaces', () => {
+    const result = resolveDbTarget(config, 'workspace', undefined);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.issue).toBe('instance_id_required');
+  });
+
+  it('rejects empty instance ids without rewriting non-empty ones', () => {
+    const empty = resolveDbTarget(config, 'workspace', '   ');
+    expect(empty.ok).toBe(false);
+    if (empty.ok) return;
+    expect(empty.issue).toBe('instance_id_empty');
+    expect(formatDbTargetValidationIssue(empty.issue, 'workspace')).toBe(
+      'instanceId must not be empty',
+    );
+
+    const preserved = resolveDbTarget(config, 'workspace', ' ws-1 ');
+    expect(preserved.ok).toBe(true);
+    if (!preserved.ok) return;
+    expect(preserved.value.instanceId).toBe(' ws-1 ');
+  });
+
+  it('rejects ids containing colons', () => {
+    const result = resolveDbTarget(config, 'workspace', 'ws:1');
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.issue).toBe('instance_id_invalid');
+  });
+
+  it('returns not-found when the namespace is missing', () => {
+    const result = resolveDbTarget(config, 'missing', undefined);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.status).toBe(404);
+    expect(result.issue).toBe('namespace_not_found');
+  });
+});
+
 describe('shouldRouteToD1', () => {
   it('namespace not in config → false', () => {
     expect(shouldRouteToD1('unknown', {})).toBe(false);

package/src/__tests__/error-format.test.ts

@@ -154,6 +154,13 @@ describe('hookRejectedError', () => {
     expect(hookRejectedError(original)).toBe(original);
   });
 
+  it('uses the fallback message and hook prefix for unauthorized non-Error rejections', () => {
+    const err = hookRejectedError('plain failure', 'Authentication required', 'beforeSave');
+    expect(err.code).toBe(401);
+    expect(err.message).toBe("Hook 'beforeSave' rejected: Authentication required");
+    expect(err.slug).toBe('hook-rejected');
+  });
+
   it('maps ownership denial messages to 403', () => {
     const err = hookRejectedError(new Error('Only owners can update this record.'));
     expect(err.code).toBe(403);
@@ -171,6 +178,18 @@ describe('hookRejectedError', () => {
     expect(err.code).toBe(409);
   });
 
+  it('maps not-found style messages to 404', () => {
+    const err = hookRejectedError(new Error('Unknown project id.'));
+    expect(err.code).toBe(404);
+    expect(err.message).toBe('Unknown project id.');
+  });
+
+  it('maps rate-limit style messages to 429', () => {
+    const err = hookRejectedError(new Error('Too many uploads, throttled.'));
+    expect(err.code).toBe(429);
+    expect(err.slug).toBe('hook-rejected');
+  });
+
   it('falls back to validation errors for unknown hook failures', () => {
     const err = hookRejectedError(new Error('Custom hook failure.'));
     expect(err.code).toBe(400);
@@ -179,6 +198,11 @@ describe('hookRejectedError', () => {
 });
 
 describe('normalizeDatabaseError', () => {
+  it('passes EdgeBaseError instances through untouched', () => {
+    const original = validationError('Already normalized');
+    expect(normalizeDatabaseError(original)).toBe(original);
+  });
+
   it('maps foreign key failures to validation errors', () => {
     const err = normalizeDatabaseError(new Error('D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT'));
     expect(err).toBeInstanceOf(EdgeBaseError);
@@ -187,6 +211,13 @@ describe('normalizeDatabaseError', () => {
     expect(err?.slug).toBe('foreign-key-failed');
   });
 
+  it('maps foreign key failures without a detected column to the generic message', () => {
+    const err = normalizeDatabaseError('FOREIGN KEY constraint failed');
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(400);
+    expect(err?.message).toContain('Check that all foreign key references');
+  });
+
   it('maps foreign key failures from cross-realm error-like objects', () => {
     const err = normalizeDatabaseError({
       message: 'D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT',
@@ -204,6 +235,38 @@ describe('normalizeDatabaseError', () => {
     expect(err?.slug).toBe('record-already-exists');
   });
 
+  it('maps unique constraint failures without a parsed column to a generic conflict message', () => {
+    const err = normalizeDatabaseError('UNIQUE constraint failed');
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(409);
+    expect(err?.message).toBe('Record already exists. A unique constraint was violated.');
+  });
+
+  it('maps not-null constraint failures to validation errors', () => {
+    const err = normalizeDatabaseError(new Error('NOT NULL constraint failed: users.email'));
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(400);
+    expect(err?.message).toContain("'email'");
+    expect(err?.slug).toBe('constraint-failed');
+  });
+
+  it('maps cause-only check constraint failures to a generic validation error', () => {
+    const err = normalizeDatabaseError({
+      message: 'outer wrapper',
+      cause: {
+        message: 'check constraint failed',
+      },
+    });
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(400);
+    expect(err?.message).toBe('Request violates a database constraint. Ensure all required fields are provided.');
+    expect(err?.slug).toBe('constraint-failed');
+  });
+
+  it('returns null for blank string inputs', () => {
+    expect(normalizeDatabaseError('   ')).toBeNull();
+  });
+
   it('returns null for unrelated runtime errors', () => {
     expect(normalizeDatabaseError(new Error('socket hang up'))).toBeNull();
   });