@edge-base/server 0.1.1

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

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { executeD1Sql } from '../lib/d1-sql.js';
+
+interface MockCall {
+  bindings: unknown[];
+  method: 'all' | 'run';
+  sql: string;
+}
+
+function createMockD1(options: {
+  allResult?: { results?: Record<string, unknown>[] };
+  runResult?: { meta?: { changes?: number } };
+} = {}): D1Database & { _calls: MockCall[] } {
+  const calls: MockCall[] = [];
+
+  function makeStmt(sql: string) {
+    const call: MockCall = {
+      bindings: [],
+      method: 'run',
+      sql,
+    };
+    calls.push(call);
+
+    const stmt = {
+      bind: (...values: unknown[]) => {
+        call.bindings = values;
+        return stmt;
+      },
+      all: async () => {
+        call.method = 'all';
+        return options.allResult ?? { results: [] };
+      },
+      run: async () => {
+        call.method = 'run';
+        return options.runResult ?? { meta: { changes: 0 } };
+      },
+    };
+
+    return stmt;
+  }
+
+  return {
+    _calls: calls,
+    prepare: (sql: string) => makeStmt(sql),
+  } as unknown as D1Database & { _calls: MockCall[] };
+}
+
+describe('executeD1Sql', () => {
+  it('returns rows for SELECT-style queries and binds parameters', async () => {
+    const db = createMockD1({
+      allResult: {
+        results: [{ id: 'post_1', title: 'Hello' }],
+      },
+    });
+
+    const result = await executeD1Sql(
+      db,
+      'SELECT * FROM posts WHERE id = ?',
+      ['post_1'],
+    );
+
+    expect(result).toEqual({
+      rowCount: 1,
+      rows: [{ id: 'post_1', title: 'Hello' }],
+    });
+    expect(db._calls).toEqual([
+      {
+        bindings: ['post_1'],
+        method: 'all',
+        sql: 'SELECT * FROM posts WHERE id = ?',
+      },
+    ]);
+  });
+
+  it('returns affected row count for write queries', async () => {
+    const db = createMockD1({
+      runResult: {
+        meta: { changes: 2 },
+      },
+    });
+
+    const result = await executeD1Sql(
+      db,
+      'UPDATE posts SET published = ? WHERE category = ?',
+      [true, 'news'],
+    );
+
+    expect(result).toEqual({
+      rowCount: 2,
+      rows: [],
+    });
+    expect(db._calls).toEqual([
+      {
+        bindings: [true, 'news'],
+        method: 'run',
+        sql: 'UPDATE posts SET published = ? WHERE category = ?',
+      },
+    ]);
+  });
+
+  it('treats RETURNING queries as row-producing even when they mutate data', async () => {
+    const db = createMockD1({
+      allResult: {
+        results: [{ id: 'post_2', published: true }],
+      },
+    });
+
+    const result = await executeD1Sql(
+      db,
+      'UPDATE posts SET published = 1 WHERE id = ? RETURNING id, published',
+      ['post_2'],
+    );
+
+    expect(result).toEqual({
+      rowCount: 1,
+      rows: [{ id: 'post_2', published: true }],
+    });
+    expect(db._calls[0]?.method).toBe('all');
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import type { EdgeBaseConfig } from '@edge-base/shared';
+import {
+  DEFAULT_DB_LIVE_AUTH_TIMEOUT_MS,
+  DEFAULT_DB_LIVE_BATCH_THRESHOLD,
+  resolveDbLiveAuthTimeoutMs,
+  resolveDbLiveBatchThreshold,
+} from '../lib/database-live-config.js';
+
+describe('database-live-config helpers', () => {
+  it('uses configured positive database-live auth timeout', () => {
+    const config = {
+      databaseLive: { authTimeoutMs: 12000 },
+    } as EdgeBaseConfig;
+
+    expect(resolveDbLiveAuthTimeoutMs(config)).toBe(12000);
+  });
+
+  it('falls back for invalid database-live auth timeout values', () => {
+    const config = {
+      databaseLive: { authTimeoutMs: 0 },
+    } as EdgeBaseConfig;
+
+    expect(resolveDbLiveAuthTimeoutMs(config)).toBe(DEFAULT_DB_LIVE_AUTH_TIMEOUT_MS);
+  });
+
+  it('uses configured positive batch threshold', () => {
+    const config = {
+      databaseLive: { batchThreshold: 3 },
+    } as EdgeBaseConfig;
+
+    expect(resolveDbLiveBatchThreshold(config)).toBe(3);
+  });
+
+  it('falls back for invalid batch threshold values', () => {
+    const config = {
+      databaseLive: { batchThreshold: -1 },
+    } as EdgeBaseConfig;
+
+    expect(resolveDbLiveBatchThreshold(config)).toBe(DEFAULT_DB_LIVE_BATCH_THRESHOLD);
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildDbLiveChannel, emitDbLiveBatchEvent, emitDbLiveEvent } from '../lib/database-live-emitter.js';
+
+describe('buildDbLiveChannel', () => {
+  it('builds shared table channels with namespace', () => {
+    expect(buildDbLiveChannel('shared', 'posts')).toBe('dblive:shared:posts');
+    expect(buildDbLiveChannel('shared', 'posts', undefined, 'p1')).toBe('dblive:shared:posts:p1');
+  });
+
+  it('builds dynamic table channels with namespace and instance id', () => {
+    expect(buildDbLiveChannel('workspace', 'documents', 'ws-123')).toBe('dblive:workspace:ws-123:documents');
+    expect(buildDbLiveChannel('workspace', 'documents', 'ws-123', 'doc-9')).toBe('dblive:workspace:ws-123:documents:doc-9');
+  });
+});
+
+describe('database-live emitter', () => {
+  it('emits shared-table events to namespace-aware table and doc channels', async () => {
+    const fetch = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
+    const get = vi.fn().mockReturnValue({ fetch });
+    const env = {
+      DATABASE_LIVE: {
+        idFromName: vi.fn((name: string) => name),
+        get,
+      },
+    } as any;
+
+    emitDbLiveEvent(env, 'shared', 'posts', 'added', 'post-1', { id: 'post-1' });
+    await Promise.resolve();
+
+    expect(env.DATABASE_LIVE.idFromName).toHaveBeenCalledWith('database-live:hub');
+    expect(fetch).toHaveBeenCalledTimes(2);
+    const tablePayload = JSON.parse(fetch.mock.calls[0]![1].body as string);
+    const docPayload = JSON.parse(fetch.mock.calls[1]![1].body as string);
+    expect(tablePayload.channel).toBe('dblive:shared:posts');
+    expect(docPayload.channel).toBe('dblive:shared:posts:post-1');
+  });
+
+  it('emits batch events to the namespace-aware table channel', async () => {
+    const fetch = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
+    const get = vi.fn().mockReturnValue({ fetch });
+    const env = {
+      DATABASE_LIVE: {
+        idFromName: vi.fn((name: string) => name),
+        get,
+      },
+    } as any;
+
+    emitDbLiveBatchEvent(env, 'workspace', 'documents', [{ type: 'modified', docId: 'd1', data: { id: 'd1' } }], 'ws-9');
+    await Promise.resolve();
+
+    expect(env.DATABASE_LIVE.idFromName).toHaveBeenCalledWith('database-live:hub');
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const payload = JSON.parse(fetch.mock.calls[0]![1].body as string);
+    expect(payload.channel).toBe('dblive:workspace:ws-9:documents');
+  });
+});

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

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('cloudflare:workers', () => ({
+  DurableObject: class DurableObject {},
+}));
+
+describe('database-live filter helpers', () => {
+  it('normalizes tuple filters for contains-any and not in operators', async () => {
+    const { normalizeDatabaseLiveFilterPayload } = await import('../durable-objects/database-live-do.js');
+
+    const normalized = normalizeDatabaseLiveFilterPayload([
+      ['tags', 'contains-any', ['hot', 'featured']],
+      ['status', 'not in', ['archived']],
+    ], 'Filters');
+
+    expect(normalized.ok).toBe(true);
+    if (!normalized.ok) {
+      throw new Error(normalized.message);
+    }
+    expect(normalized.value).toEqual([
+      ['tags', 'contains-any', ['hot', 'featured']],
+      ['status', 'not in', ['archived']],
+    ]);
+  });
+
+  it('evaluates AND filters together with OR-group semantics', async () => {
+    const { evaluateDatabaseLiveFilters } = await import('../durable-objects/database-live-do.js');
+
+    expect(evaluateDatabaseLiveFilters(
+      {
+        score: 12,
+        status: 'published',
+        tags: ['cold'],
+        title: 'Hello World',
+      },
+      [
+        ['score', '>', 10],
+        ['status', 'not in', ['draft', 'archived']],
+      ],
+      [
+        ['tags', 'contains-any', ['hot']],
+        ['title', 'contains', 'World'],
+      ],
+    )).toBe(true);
+
+    expect(evaluateDatabaseLiveFilters(
+      {
+        score: 12,
+        status: 'published',
+        tags: ['cold'],
+        title: 'Hello there',
+      },
+      [
+        ['score', '>', 10],
+        ['status', 'not in', ['draft', 'archived']],
+      ],
+      [
+        ['tags', 'contains-any', ['hot']],
+        ['title', 'contains', 'World'],
+      ],
+    )).toBe(false);
+  });
+});

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

@@ -0,0 +1,113 @@
+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 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 createMockEnv(
+  kv: KVNamespace & { _store: MockKVStore },
+  onFetch?: (request: Request) => Response | Promise<Response>,
+): Env {
+  return {
+    KV: kv,
+    DATABASE_LIVE: {
+      idFromName: (name: string) => name as unknown as DurableObjectId,
+      get: () => ({
+        fetch: async (request: Request) => onFetch?.(request) ?? new Response(null, { status: 200 }),
+      }),
+    } as unknown as DurableObjectNamespace,
+  } as unknown as Env;
+}
+
+function createApp() {
+  const app = new OpenAPIHono<HonoEnv>();
+  app.route('/api/db', databaseLiveRoute);
+  return app;
+}
+
+describe('database live subscription route', () => {
+  afterEach(() => {
+    setConfig({});
+  });
+
+  it('reports connect-check readiness for explicit database params', async () => {
+    const kv = createMockKV();
+    const app = createApp();
+
+    const response = await app.request('/api/db/connect-check?namespace=shared&table=posts', {
+      method: 'GET',
+      headers: {
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockEnv(kv));
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      type: 'db_connect_ready',
+      category: 'ready',
+      channel: 'dblive:shared:posts',
+    });
+  });
+
+  it('rejects non-database-live channels on database entrypoints', async () => {
+    const kv = createMockKV();
+    const app = createApp();
+
+    const response = await app.request('/api/db/connect-check?channel=dblive:presence:lobby', {
+      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',
+      category: 'request',
+    });
+  });
+
+  it('proxies websocket subscribe requests through the database-owned path and releases pending slots', async () => {
+    const kv = createMockKV();
+    const app = createApp();
+    let forwardedUrl = '';
+
+    const response = await app.request('/api/db/subscribe?namespace=workspace&instanceId=ws-9&table=posts&docId=doc-1', {
+      method: 'GET',
+      headers: {
+        Upgrade: 'websocket',
+        'CF-Connecting-IP': '127.0.0.1',
+      },
+    }, createMockEnv(kv, async (request) => {
+      forwardedUrl = request.url;
+      return new Response(null, { status: 200 });
+    }));
+
+    expect(response.status).toBe(200);
+    expect(forwardedUrl).toContain('/websocket?channel=dblive%3Aworkspace%3Aws-9%3Aposts%3Adoc-1');
+    expect(kv._store.data['ws:pending:127.0.0.1']).toBeUndefined();
+  });
+});

package/src/__tests__/db-sql.test.ts

@@ -0,0 +1,163 @@
+/**
+ * 서버 단위 테스트 — lib/db-sql.ts
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/db-sql.test.ts
+ *
+ * 테스트 대상:
+ *   RawSql / raw / buildSqlQuery / createSqlTaggedTemplate
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { RawSql, raw, buildSqlQuery, createSqlTaggedTemplate } from '../lib/db-sql.js';
+
+// ─── A. RawSql ──────────────────────────────────────────────────────────────
+
+describe('RawSql', () => {
+  it('stores value property', () => {
+    const r = new RawSql('table_name');
+    expect(r.value).toBe('table_name');
+  });
+
+  it('is instanceof RawSql', () => {
+    const r = new RawSql('x');
+    expect(r instanceof RawSql).toBe(true);
+  });
+
+  it('value is readonly (reflected in type)', () => {
+    const r = new RawSql('abc');
+    expect(r.value).toBe('abc');
+  });
+});
+
+// ─── B. raw() ───────────────────────────────────────────────────────────────
+
+describe('raw()', () => {
+  it('returns a RawSql instance', () => {
+    const r = raw('my_table');
+    expect(r).toBeInstanceOf(RawSql);
+    expect(r.value).toBe('my_table');
+  });
+
+  it('empty string raw', () => {
+    const r = raw('');
+    expect(r.value).toBe('');
+  });
+});
+
+// ─── C. buildSqlQuery ───────────────────────────────────────────────────────
+
+describe('buildSqlQuery', () => {
+  // Helper to create tagged template arrays
+  function sql(strings: TemplateStringsArray, ...values: unknown[]) {
+    return buildSqlQuery(strings, ...values);
+  }
+
+  it('no interpolation → just the query', () => {
+    const result = sql`SELECT * FROM users`;
+    expect(result.query).toBe('SELECT * FROM users');
+    expect(result.params).toEqual([]);
+  });
+
+  it('single parameterized value', () => {
+    const result = sql`SELECT * FROM users WHERE id = ${123}`;
+    expect(result.query).toBe('SELECT * FROM users WHERE id = ?');
+    expect(result.params).toEqual([123]);
+  });
+
+  it('multiple parameterized values', () => {
+    const result = sql`INSERT INTO t (a, b) VALUES (${1}, ${'hello'})`;
+    expect(result.query).toBe('INSERT INTO t (a, b) VALUES (?, ?)');
+    expect(result.params).toEqual([1, 'hello']);
+  });
+
+  it('RawSql bypasses parameterization', () => {
+    const tableName = raw('users');
+    const result = sql`SELECT * FROM ${tableName} WHERE id = ${42}`;
+    expect(result.query).toBe('SELECT * FROM users WHERE id = ?');
+    expect(result.params).toEqual([42]);
+  });
+
+  it('mixed raw and parameterized', () => {
+    const col = raw('"name"');
+    const result = sql`UPDATE ${raw('posts')} SET ${col} = ${'new title'} WHERE id = ${5}`;
+    expect(result.query).toBe('UPDATE posts SET "name" = ? WHERE id = ?');
+    expect(result.params).toEqual(['new title', 5]);
+  });
+
+  it('null and undefined as params', () => {
+    const result = sql`INSERT INTO t (a, b) VALUES (${null}, ${undefined})`;
+    expect(result.params).toEqual([null, undefined]);
+    expect(result.query).toBe('INSERT INTO t (a, b) VALUES (?, ?)');
+  });
+
+  it('boolean as param', () => {
+    const result = sql`UPDATE t SET active = ${true}`;
+    expect(result.params).toEqual([true]);
+  });
+
+  it('only raw values → no params', () => {
+    const result = sql`SELECT * FROM ${raw('users')} ORDER BY ${raw('"created_at"')} DESC`;
+    expect(result.query).toBe('SELECT * FROM users ORDER BY "created_at" DESC');
+    expect(result.params).toEqual([]);
+  });
+});
+
+// ─── D. createSqlTaggedTemplate ─────────────────────────────────────────────
+
+describe('createSqlTaggedTemplate', () => {
+  it('executes query with correct params and returns rows', () => {
+    const mockExec = vi.fn((..._args: unknown[]) =>
+      [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }] as Iterable<Record<string, unknown>>,
+    );
+    const sql = createSqlTaggedTemplate(mockExec);
+
+    const result = sql`SELECT * FROM users WHERE active = ${true}`;
+
+    expect(mockExec).toHaveBeenCalledWith('SELECT * FROM users WHERE active = ?', true);
+    expect(result).toEqual([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]);
+  });
+
+  it('spreads multiple params correctly', () => {
+    const mockExec = vi.fn((..._args: unknown[]) => [] as Iterable<Record<string, unknown>>);
+    const sql = createSqlTaggedTemplate(mockExec);
+
+    void sql`INSERT INTO t (a, b, c) VALUES (${1}, ${'two'}, ${null})`;
+
+    expect(mockExec).toHaveBeenCalledWith(
+      'INSERT INTO t (a, b, c) VALUES (?, ?, ?)',
+      1, 'two', null,
+    );
+  });
+
+  it('raw values are inlined, not passed as params', () => {
+    const mockExec = vi.fn((..._args: unknown[]) => [] as Iterable<Record<string, unknown>>);
+    const sql = createSqlTaggedTemplate(mockExec);
+
+    void sql`SELECT * FROM ${raw('my_table')} WHERE id = ${42}`;
+
+    expect(mockExec).toHaveBeenCalledWith('SELECT * FROM my_table WHERE id = ?', 42);
+  });
+
+  it('no-param query passes only query string', () => {
+    const mockExec = vi.fn((..._args: unknown[]) => [] as Iterable<Record<string, unknown>>);
+    const sql = createSqlTaggedTemplate(mockExec);
+
+    void sql`SELECT 1`;
+
+    expect(mockExec).toHaveBeenCalledWith('SELECT 1');
+  });
+
+  it('iterates cursor and returns array', () => {
+    // Simulate a generator/iterable cursor
+    function* cursor() {
+      yield { id: 1 };
+      yield { id: 2 };
+      yield { id: 3 };
+    }
+    const mockExec = vi.fn(() => cursor());
+    const sql = createSqlTaggedTemplate(mockExec);
+
+    const result = sql`SELECT * FROM t`;
+    expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+  });
+});