@edge-base/server 0.1.1

package/src/__tests__/cron.test.ts

@@ -0,0 +1,302 @@
+/**
+ * 서버 단위 테스트 — lib/cron.ts
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/cron.test.ts
+ *
+ * 테스트 대상:
+ *   parseCronField / parseCron / matchesCron / getNextFireTime / getNextAlarm
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  parseCronField,
+  parseCron,
+  matchesCron,
+  getNextFireTime,
+  getNextAlarm,
+  type ParsedScheduleFunction,
+} from '../lib/cron.js';
+
+// ─── A. parseCronField ──────────────────────────────────────────────────────
+
+describe('parseCronField', () => {
+  it('* → all values in range', () => {
+    const result = parseCronField('*', 0, 59);
+    expect(result.size).toBe(60);
+    expect(result.has(0)).toBe(true);
+    expect(result.has(59)).toBe(true);
+  });
+
+  it('single value', () => {
+    const result = parseCronField('5', 0, 59);
+    expect(result.size).toBe(1);
+    expect(result.has(5)).toBe(true);
+  });
+
+  it('range N-M', () => {
+    const result = parseCronField('10-15', 0, 59);
+    expect(result.size).toBe(6);
+    for (let i = 10; i <= 15; i++) expect(result.has(i)).toBe(true);
+    expect(result.has(9)).toBe(false);
+    expect(result.has(16)).toBe(false);
+  });
+
+  it('*/step (star step)', () => {
+    const result = parseCronField('*/5', 0, 59);
+    expect(result.has(0)).toBe(true);
+    expect(result.has(5)).toBe(true);
+    expect(result.has(10)).toBe(true);
+    expect(result.has(55)).toBe(true);
+    expect(result.has(3)).toBe(false);
+  });
+
+  it('range/step (N-M/step)', () => {
+    const result = parseCronField('0-30/5', 0, 59);
+    expect([...result].sort((a, b) => a - b)).toEqual([0, 5, 10, 15, 20, 25, 30]);
+  });
+
+  it('comma-separated list', () => {
+    const result = parseCronField('1,15,30', 0, 59);
+    expect(result.size).toBe(3);
+    expect(result.has(1)).toBe(true);
+    expect(result.has(15)).toBe(true);
+    expect(result.has(30)).toBe(true);
+  });
+
+  it('mixed list: value, range, step', () => {
+    const result = parseCronField('0,10-12,*/20', 0, 59);
+    // 0, 10, 11, 12, 0, 20, 40 → unique: {0, 10, 11, 12, 20, 40}
+    expect(result.has(0)).toBe(true);
+    expect(result.has(10)).toBe(true);
+    expect(result.has(11)).toBe(true);
+    expect(result.has(12)).toBe(true);
+    expect(result.has(20)).toBe(true);
+    expect(result.has(40)).toBe(true);
+  });
+
+  it('step 0 → throws', () => {
+    expect(() => parseCronField('*/0', 0, 59)).toThrow('Invalid cron step');
+  });
+
+  it('out of range single value → throws', () => {
+    expect(() => parseCronField('60', 0, 59)).toThrow();
+  });
+
+  it('below min → throws', () => {
+    expect(() => parseCronField('-1', 0, 59)).toThrow();
+  });
+
+  it('non-numeric → throws', () => {
+    expect(() => parseCronField('abc', 0, 59)).toThrow();
+  });
+
+  it('day of week 0-6', () => {
+    const result = parseCronField('0', 0, 6);
+    expect(result.has(0)).toBe(true);
+  });
+
+  it('month 1-12 single', () => {
+    const result = parseCronField('12', 1, 12);
+    expect(result.has(12)).toBe(true);
+  });
+
+  it('whitespace in comma list trimmed', () => {
+    const result = parseCronField('1, 2, 3', 0, 59);
+    expect(result.size).toBe(3);
+  });
+});
+
+// ─── B. parseCron ───────────────────────────────────────────────────────────
+
+describe('parseCron', () => {
+  it('every day at 09:00 → minute=0, hour=9', () => {
+    const sched = parseCron('0 9 * * *');
+    expect(sched.minutes.has(0)).toBe(true);
+    expect(sched.minutes.size).toBe(1);
+    expect(sched.hours.has(9)).toBe(true);
+    expect(sched.hours.size).toBe(1);
+    expect(sched.daysOfMonth.size).toBe(31);
+    expect(sched.months.size).toBe(12);
+    expect(sched.daysOfWeek.size).toBe(7);
+  });
+
+  it('every 5 minutes', () => {
+    const sched = parseCron('*/5 * * * *');
+    expect(sched.minutes.size).toBe(12); // 0,5,10,...,55
+    expect(sched.minutes.has(0)).toBe(true);
+    expect(sched.minutes.has(55)).toBe(true);
+    expect(sched.minutes.has(3)).toBe(false);
+  });
+
+  it('every Monday at 02:30', () => {
+    const sched = parseCron('30 2 * * 1');
+    expect(sched.minutes.has(30)).toBe(true);
+    expect(sched.hours.has(2)).toBe(true);
+    expect(sched.daysOfWeek.has(1)).toBe(true);
+    expect(sched.daysOfWeek.size).toBe(1);
+  });
+
+  it('first day of every month at midnight', () => {
+    const sched = parseCron('0 0 1 * *');
+    expect(sched.minutes.has(0)).toBe(true);
+    expect(sched.hours.has(0)).toBe(true);
+    expect(sched.daysOfMonth.has(1)).toBe(true);
+    expect(sched.daysOfMonth.size).toBe(1);
+  });
+
+  it('wrong number of fields → throws', () => {
+    expect(() => parseCron('* * *')).toThrow('expected 5 fields');
+  });
+
+  it('6 fields → throws', () => {
+    expect(() => parseCron('0 0 0 0 0 0')).toThrow('expected 5 fields');
+  });
+
+  it('extra whitespace is trimmed', () => {
+    const sched = parseCron('  0  9  *  *  *  ');
+    expect(sched.minutes.has(0)).toBe(true);
+    expect(sched.hours.has(9)).toBe(true);
+  });
+});
+
+// ─── C. matchesCron ─────────────────────────────────────────────────────────
+
+describe('matchesCron', () => {
+  it('matches exact time', () => {
+    const sched = parseCron('30 14 * * *');
+    // 2024-06-15 14:30 UTC is a Saturday (day 6)
+    const date = new Date('2024-06-15T14:30:00Z');
+    expect(matchesCron(date, sched)).toBe(true);
+  });
+
+  it('does not match wrong minute', () => {
+    const sched = parseCron('30 14 * * *');
+    const date = new Date('2024-06-15T14:31:00Z');
+    expect(matchesCron(date, sched)).toBe(false);
+  });
+
+  it('does not match wrong hour', () => {
+    const sched = parseCron('30 14 * * *');
+    const date = new Date('2024-06-15T15:30:00Z');
+    expect(matchesCron(date, sched)).toBe(false);
+  });
+
+  it('day of week matters', () => {
+    const sched = parseCron('0 0 * * 1'); // Monday only
+    // 2024-06-17 is Monday
+    expect(matchesCron(new Date('2024-06-17T00:00:00Z'), sched)).toBe(true);
+    // 2024-06-18 is Tuesday
+    expect(matchesCron(new Date('2024-06-18T00:00:00Z'), sched)).toBe(false);
+  });
+
+  it('month matters', () => {
+    const sched = parseCron('0 0 1 6 *'); // June 1st only
+    expect(matchesCron(new Date('2024-06-01T00:00:00Z'), sched)).toBe(true);
+    expect(matchesCron(new Date('2024-07-01T00:00:00Z'), sched)).toBe(false);
+  });
+
+  it('day of month matters', () => {
+    const sched = parseCron('0 0 15 * *'); // 15th of each month
+    expect(matchesCron(new Date('2024-06-15T00:00:00Z'), sched)).toBe(true);
+    expect(matchesCron(new Date('2024-06-14T00:00:00Z'), sched)).toBe(false);
+  });
+
+  it('uses UTC methods', () => {
+    const sched = parseCron('0 0 * * *'); // midnight UTC
+    const date = new Date('2024-06-15T00:00:00Z');
+    expect(matchesCron(date, sched)).toBe(true);
+  });
+});
+
+// ─── D. getNextFireTime ─────────────────────────────────────────────────────
+
+describe('getNextFireTime', () => {
+  it('next minute for every-minute cron', () => {
+    const sched = parseCron('* * * * *');
+    const from = new Date('2024-06-15T10:30:00Z');
+    const next = getNextFireTime(sched, from);
+    expect(next).toBe(new Date('2024-06-15T10:31:00Z').getTime());
+  });
+
+  it('next day for daily cron', () => {
+    const sched = parseCron('0 9 * * *');
+    const from = new Date('2024-06-15T10:00:00Z'); // after 09:00
+    const next = getNextFireTime(sched, from);
+    expect(next).toBe(new Date('2024-06-16T09:00:00Z').getTime());
+  });
+
+  it('same day if before target time', () => {
+    const sched = parseCron('0 14 * * *');
+    const from = new Date('2024-06-15T10:00:00Z'); // before 14:00
+    const next = getNextFireTime(sched, from);
+    expect(next).toBe(new Date('2024-06-15T14:00:00Z').getTime());
+  });
+
+  it('skips to correct day of week', () => {
+    const sched = parseCron('0 0 * * 1'); // Monday only
+    // 2024-06-15 is Saturday → next Monday is June 17
+    const from = new Date('2024-06-15T00:00:00Z');
+    const next = getNextFireTime(sched, from);
+    expect(next).toBe(new Date('2024-06-17T00:00:00Z').getTime());
+  });
+
+  it('month boundary: Dec 31 → Jan 1 next year', () => {
+    const sched = parseCron('0 0 1 1 *'); // Jan 1st midnight
+    const from = new Date('2024-12-31T23:59:00Z');
+    const next = getNextFireTime(sched, from);
+    expect(next).toBe(new Date('2025-01-01T00:00:00Z').getTime());
+  });
+
+  it('seconds are zeroed', () => {
+    const sched = parseCron('* * * * *');
+    const from = new Date('2024-06-15T10:30:45Z'); // 45 seconds
+    const next = getNextFireTime(sched, from);
+    const d = new Date(next);
+    expect(d.getUTCSeconds()).toBe(0);
+    expect(d.getUTCMilliseconds()).toBe(0);
+  });
+});
+
+// ─── E. getNextAlarm ────────────────────────────────────────────────────────
+
+describe('getNextAlarm', () => {
+  it('empty schedules → null', () => {
+    expect(getNextAlarm([], new Date())).toBe(null);
+  });
+
+  it('single schedule → returns its next fire time', () => {
+    const sched = parseCron('0 9 * * *');
+    const schedules: ParsedScheduleFunction[] = [
+      { name: 'daily', cron: '0 9 * * *', schedule: sched },
+    ];
+    const from = new Date('2024-06-15T10:00:00Z');
+    const result = getNextAlarm(schedules, from);
+    expect(result).not.toBe(null);
+    expect(result!.functions).toEqual(['daily']);
+    expect(result!.time).toBe(new Date('2024-06-16T09:00:00Z').getTime());
+  });
+
+  it('multiple schedules → picks earliest', () => {
+    const schedules: ParsedScheduleFunction[] = [
+      { name: 'hourly', cron: '0 * * * *', schedule: parseCron('0 * * * *') },
+      { name: 'daily', cron: '0 9 * * *', schedule: parseCron('0 9 * * *') },
+    ];
+    const from = new Date('2024-06-15T10:30:00Z');
+    const result = getNextAlarm(schedules, from);
+    expect(result!.functions).toEqual(['hourly']);
+    // Next hour is 11:00
+    expect(result!.time).toBe(new Date('2024-06-15T11:00:00Z').getTime());
+  });
+
+  it('simultaneous fire times → groups function names', () => {
+    const schedules: ParsedScheduleFunction[] = [
+      { name: 'jobA', cron: '0 12 * * *', schedule: parseCron('0 12 * * *') },
+      { name: 'jobB', cron: '0 12 * * *', schedule: parseCron('0 12 * * *') },
+    ];
+    const from = new Date('2024-06-15T10:00:00Z');
+    const result = getNextAlarm(schedules, from);
+    expect(result!.functions).toContain('jobA');
+    expect(result!.functions).toContain('jobB');
+    expect(result!.functions.length).toBe(2);
+  });
+});

package/src/__tests__/d1-handler.test.ts

@@ -0,0 +1,402 @@
+/**
+ * 서버 단위 테스트 — D1 Schema Init + Routing
+ * d1-handler.test.ts
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/d1-handler.test.ts
+ *
+ * 테스트 대상:
+ *   A. ensureD1Schema — lazy schema initialization
+ *   B. _resetD1SchemaCache — cache invalidation
+ *   C. shouldRouteToD1 / getD1BindingName — routing (also in do-router.test.ts)
+ *   D. D1 meta helpers (schemaHash, migration_version)
+ *   E. D1 migration engine
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ensureD1Schema, _resetD1SchemaCache } from '../lib/d1-schema-init.js';
+import { shouldRouteToD1, getD1BindingName } from '../lib/do-router.js';
+import type { TableConfig } from '@edge-base/shared';
+
+// ─── Mock D1 ─────────────────────────────────────────────────────────────────
+
+interface MockCall {
+  sql: string;
+  bindings: unknown[];
+  method: 'first' | 'all' | 'run';
+}
+
+function createMockD1(options: {
+  firstResult?: unknown;
+  allResult?: { results: unknown[] };
+  /** Per-call sequential results for `.first()` */
+  firstResults?: unknown[];
+  /** Per-call sequential results for `.all()` */
+  allResults?: Array<{ results: unknown[] }>;
+} = {}): D1Database & { _calls: MockCall[]; _batchCalls: number; _batchStmts: string[][] } {
+  const calls: MockCall[] = [];
+  let firstCallIdx = 0;
+  let allCallIdx = 0;
+  let batchCalls = 0;
+  const batchStmts: string[][] = [];
+
+  function makeStmt(sql: string): any {
+    const call: MockCall = { sql, bindings: [], method: 'run' };
+    calls.push(call);
+
+    const stmt = {
+      _sql: sql,
+      bind: (...values: unknown[]) => {
+        call.bindings = values;
+        return stmt;
+      },
+      first: async () => {
+        call.method = 'first';
+        if (options.firstResults && firstCallIdx < options.firstResults.length) {
+          return options.firstResults[firstCallIdx++];
+        }
+        return options.firstResult ?? null;
+      },
+      all: async () => {
+        call.method = 'all';
+        if (options.allResults && allCallIdx < options.allResults.length) {
+          return options.allResults[allCallIdx++];
+        }
+        return options.allResult ?? { results: [] };
+      },
+      run: async () => {
+        call.method = 'run';
+        return { success: true };
+      },
+    };
+    return stmt;
+  }
+
+  const db = {
+    prepare: (sql: string) => makeStmt(sql),
+    batch: async (stmts: any[]) => {
+      batchCalls++;
+      batchStmts.push(stmts.map((s: any) => s._sql));
+      return stmts;
+    },
+    _calls: calls,
+    _batchCalls: 0,
+    _batchStmts: batchStmts,
+  };
+
+  Object.defineProperty(db, '_batchCalls', { get: () => batchCalls });
+
+  return db as any;
+}
+
+// ─── A. ensureD1Schema ───────────────────────────────────────────────────────
+
+describe('ensureD1Schema', () => {
+  beforeEach(() => {
+    _resetD1SchemaCache();
+  });
+
+  const simpleTables: Record<string, TableConfig> = {
+    posts: {
+      schema: {
+        title: { type: 'string' },
+        content: { type: 'text' },
+      },
+    },
+  };
+
+  it('creates _meta table on first call', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+
+    // First call should be _meta DDL
+    const metaCall = db._calls.find(c => c.sql.includes('_meta'));
+    expect(metaCall).toBeDefined();
+  });
+
+  it('enables foreign keys via PRAGMA', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+
+    const pragmaCall = db._calls.find(c => c.sql.includes('PRAGMA foreign_keys'));
+    expect(pragmaCall).toBeDefined();
+  });
+
+  it('checks schema hash for each table', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+
+    // Should query _meta for schemaHash:posts
+    const hashCheck = db._calls.find(c =>
+      c.sql.includes('_meta') && c.bindings.includes('schemaHash:posts'),
+    );
+    expect(hashCheck).toBeDefined();
+  });
+
+  it('creates table DDL when no stored hash exists', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+
+    // Should batch table creation DDLs
+    expect(db._batchCalls).toBeGreaterThan(0);
+  });
+
+  it('stores schema hash after table creation', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+
+    // Should INSERT INTO _meta with schemaHash:posts
+    const hashStore = db._calls.find(c =>
+      c.sql.includes('INSERT INTO "_meta"') && c.bindings[0] === 'schemaHash:posts',
+    );
+    expect(hashStore).toBeDefined();
+    // Hash value should be a non-empty string
+    expect(hashStore!.bindings[1]).toBeTruthy();
+  });
+
+  it('skips re-init on second call (memory cache)', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+    const callCount = db._calls.length;
+
+    // Second call should be no-op
+    await ensureD1Schema(db, 'shared', simpleTables);
+    expect(db._calls.length).toBe(callCount); // no new calls
+  });
+
+  it('different namespaces are tracked independently', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+    const callCount1 = db._calls.length;
+
+    // Different namespace should trigger init
+    await ensureD1Schema(db, 'analytics', { events: { schema: { name: { type: 'string' } } } });
+    expect(db._calls.length).toBeGreaterThan(callCount1);
+  });
+
+  it('_resetD1SchemaCache clears the memory cache', async () => {
+    const db = createMockD1();
+    await ensureD1Schema(db, 'shared', simpleTables);
+    const callCount = db._calls.length;
+
+    _resetD1SchemaCache();
+    await ensureD1Schema(db, 'shared', simpleTables);
+    // Should re-run init after cache clear
+    expect(db._calls.length).toBeGreaterThan(callCount);
+  });
+});
+
+// ─── B. ensureD1Schema — schema update (hash mismatch) ──────────────────────
+
+describe('ensureD1Schema — schema update', () => {
+  beforeEach(() => {
+    _resetD1SchemaCache();
+  });
+
+  it('detects schema hash mismatch and runs PRAGMA table_info', async () => {
+    // Simulate: _meta has a stale hash for 'posts'
+    const db = createMockD1({
+      // first .first() call returns stale hash, rest return null
+      firstResults: [{ value: 'stale-hash' }],
+      // PRAGMA table_info returns existing columns
+      allResult: { results: [{ name: 'id' }, { name: 'title' }] },
+    });
+
+    await ensureD1Schema(db, 'shared', {
+      posts: {
+        schema: {
+          title: { type: 'string' },
+          content: { type: 'text' }, // new column
+        },
+      },
+    });
+
+    // Should run PRAGMA table_info to detect existing columns
+    const pragmaInfo = db._calls.find(c => c.sql.includes('PRAGMA table_info'));
+    expect(pragmaInfo).toBeDefined();
+  });
+});
+
+// ─── C. ensureD1Schema — migrations ─────────────────────────────────────────
+
+describe('ensureD1Schema — migrations', () => {
+  beforeEach(() => {
+    _resetD1SchemaCache();
+  });
+
+  it('sets initial migration version on fresh table', async () => {
+    const db = createMockD1();
+
+    await ensureD1Schema(db, 'shared', {
+      posts: {
+        schema: { title: { type: 'string' } },
+        migrations: [
+          { version: 2, description: 'Add slug column', up: 'ALTER TABLE posts ADD COLUMN slug TEXT' },
+          { version: 3, description: 'Add slug index', up: 'CREATE INDEX idx_slug ON posts(slug)' },
+        ],
+      },
+    });
+
+    // Should set migration_version:posts to 3 (max version)
+    const versionSet = db._calls.find(c =>
+      c.sql.includes('INSERT INTO "_meta"') && c.bindings[0] === 'migration_version:posts',
+    );
+    expect(versionSet).toBeDefined();
+    expect(versionSet!.bindings[1]).toBe('3');
+  });
+
+  it('runs pending migrations when schema hash matches', async () => {
+    // We need to force hash match — pass a config that produces the stored hash
+    // Since we can't predict the hash, test that migration SQL runs
+    // Use fresh DB (no stored hash) with migrations
+    const db2 = createMockD1({
+      firstResults: [
+        null,  // schemaHash:posts → null = fresh table
+      ],
+    });
+
+    await ensureD1Schema(db2, 'shared', {
+      posts: {
+        schema: { title: { type: 'string' } },
+        migrations: [
+          { version: 2, description: 'Add category column', up: 'ALTER TABLE posts ADD COLUMN category TEXT' },
+        ],
+      },
+    });
+
+    // Fresh table: sets migration_version to max (2), skips running them
+    const versionSet = db2._calls.find(c =>
+      c.bindings[0] === 'migration_version:posts',
+    );
+    expect(versionSet).toBeDefined();
+    expect(versionSet!.bindings[1]).toBe('2');
+  });
+});
+
+// ─── D. Multiple tables in single namespace ─────────────────────────────────
+
+describe('ensureD1Schema — multiple tables', () => {
+  beforeEach(() => {
+    _resetD1SchemaCache();
+  });
+
+  it('initializes all tables in the namespace', async () => {
+    const db = createMockD1();
+
+    await ensureD1Schema(db, 'shared', {
+      posts: { schema: { title: { type: 'string' } } },
+      comments: { schema: { body: { type: 'text' } } },
+    });
+
+    // Should check hash for both tables
+    const postHash = db._calls.find(c =>
+      c.bindings.includes('schemaHash:posts'),
+    );
+    const commentHash = db._calls.find(c =>
+      c.bindings.includes('schemaHash:comments'),
+    );
+    expect(postHash).toBeDefined();
+    expect(commentHash).toBeDefined();
+  });
+});
+
+// ─── E. D1 routing integration ──────────────────────────────────────────────
+
+describe('D1 routing — shouldRouteToD1 integration', () => {
+  it('shared namespace with tables → D1 (auto-detect)', () => {
+    const config = {
+      databases: {
+        shared: {
+          tables: {
+            posts: { schema: { title: { type: 'string' } } },
+          },
+        },
+      },
+    };
+    expect(shouldRouteToD1('shared', config as any)).toBe(true);
+    expect(getD1BindingName('shared')).toBe('DB_D1_SHARED');
+  });
+
+  it('explicit provider: "d1" → D1', () => {
+    const config = {
+      databases: {
+        analytics: {
+          provider: 'd1',
+          tables: { events: {} },
+        },
+      },
+    };
+    expect(shouldRouteToD1('analytics', config as any)).toBe(true);
+    expect(getD1BindingName('analytics')).toBe('DB_D1_ANALYTICS');
+  });
+
+  it('workspace with instance: true → DO (not D1)', () => {
+    const config = {
+      databases: {
+        workspace: {
+          instance: true,
+          tables: { members: {} },
+        },
+      },
+    };
+    expect(shouldRouteToD1('workspace', config as any)).toBe(false);
+  });
+
+  it('namespace with canCreate access → DO', () => {
+    const config = {
+      databases: {
+        project: {
+          access: { canCreate: 'auth.role == "admin"' },
+          tables: { tasks: {} },
+        },
+      },
+    };
+    expect(shouldRouteToD1('project', config as any)).toBe(false);
+  });
+
+  it('namespace with access callback config → DO', () => {
+    const config = {
+      databases: {
+        project: {
+          access: { access: 'auth.id == instanceId' },
+          tables: { tasks: {} },
+        },
+      },
+    };
+    expect(shouldRouteToD1('project', config as any)).toBe(false);
+  });
+
+  it('mixed config: some D1, some DO', () => {
+    const config = {
+      databases: {
+        shared: { tables: { posts: {} } },
+        workspace: { instance: true, tables: { members: {} } },
+        logs: { provider: 'do' as const, tables: { entries: {} } },
+        analytics: { provider: 'd1' as const, tables: { events: {} } },
+      },
+    };
+    expect(shouldRouteToD1('shared', config as any)).toBe(true);
+    expect(shouldRouteToD1('workspace', config as any)).toBe(false);
+    expect(shouldRouteToD1('logs', config as any)).toBe(false);
+    expect(shouldRouteToD1('analytics', config as any)).toBe(true);
+  });
+});
+
+// ─── F. D1 binding name convention ──────────────────────────────────────────
+
+describe('getD1BindingName', () => {
+  it('simple namespace', () => {
+    expect(getD1BindingName('shared')).toBe('DB_D1_SHARED');
+  });
+
+  it('camelCase namespace → uppercased', () => {
+    expect(getD1BindingName('myData')).toBe('DB_D1_MYDATA');
+  });
+
+  it('hyphenated namespace → uppercased (with hyphen)', () => {
+    expect(getD1BindingName('my-data')).toBe('DB_D1_MY-DATA');
+  });
+
+  it('already uppercase → unchanged', () => {
+    expect(getD1BindingName('SHARED')).toBe('DB_D1_SHARED');
+  });
+});