@syncular/server 0.0.6-95 → 0.1.0

package/src/proxy/mutation-detector.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import {
-  appendReturning,
-  detectMutation,
-  hasReturningWildcard,
-} from './mutation-detector';
-
-describe('detectMutation', () => {
-  it('detects comment-prefixed update statements', () => {
-    const detected = detectMutation(`
-      /* admin tooling */
-      UPDATE tasks
-      SET title = 'updated'
-      WHERE id = 't1'
-    `);
-
-    expect(detected).toEqual({
-      operation: 'upsert',
-      tableName: 'tasks',
-    });
-  });
-
-  it('detects cte-prefixed update statements', () => {
-    const detected = detectMutation(`
-      WITH touched AS (
-        SELECT id FROM tasks WHERE id = 't1'
-      )
-      UPDATE tasks
-      SET title = 'updated'
-      WHERE id IN (SELECT id FROM touched)
-    `);
-
-    expect(detected).toEqual({
-      operation: 'upsert',
-      tableName: 'tasks',
-    });
-  });
-
-  it('returns null for cte-prefixed read queries', () => {
-    const detected = detectMutation(`
-      WITH filtered AS (
-        SELECT id FROM tasks WHERE user_id = 'u1'
-      )
-      SELECT * FROM filtered
-    `);
-
-    expect(detected).toBeNull();
-  });
-});
-
-describe('returning helpers', () => {
-  it('recognizes wildcard RETURNING clauses', () => {
-    expect(
-      hasReturningWildcard('UPDATE tasks SET title = $1 RETURNING *')
-    ).toBe(true);
-    expect(
-      hasReturningWildcard(
-        'UPDATE tasks SET title = $1 RETURNING tasks.id, tasks.*'
-      )
-    ).toBe(true);
-    expect(
-      hasReturningWildcard('UPDATE tasks SET title = $1 RETURNING id')
-    ).toBe(false);
-  });
-
-  it('appends RETURNING * when missing', () => {
-    expect(appendReturning('UPDATE tasks SET title = $1')).toBe(
-      'UPDATE tasks SET title = $1 RETURNING *'
-    );
-  });
-});

package/src/snapshot-chunks/db-metadata.test.ts

@@ -1,172 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { type BlobStorageAdapter, createDatabase } from '@syncular/core';
-import { type Kysely, sql } from 'kysely';
-import { createBunSqliteDialect } from '../../../dialect-bun-sqlite/src';
-import { createSqliteServerDialect } from '../../../server-dialect-sqlite/src';
-import { ensureSyncSchema } from '../migrate';
-import type { SyncCoreDb } from '../schema';
-import { createDbMetadataChunkStorage } from './db-metadata';
-
-interface TestDb extends SyncCoreDb {}
-
-function createInMemoryBlobAdapter(): BlobStorageAdapter {
-  const store = new Map<string, Uint8Array>();
-
-  return {
-    name: 'memory',
-    async signUpload() {
-      return { url: 'https://example.test/upload', method: 'PUT' };
-    },
-    async signDownload() {
-      return 'https://example.test/download';
-    },
-    async exists(hash) {
-      return store.has(hash);
-    },
-    async delete(hash) {
-      store.delete(hash);
-    },
-    async put(hash, data) {
-      store.set(hash, new Uint8Array(data));
-    },
-    async get(hash) {
-      const value = store.get(hash);
-      return value ? new Uint8Array(value) : null;
-    },
-  };
-}
-
-function createBodyStream(
-  chunks: readonly Uint8Array[]
-): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      for (const chunk of chunks) {
-        controller.enqueue(chunk);
-      }
-      controller.close();
-    },
-  });
-}
-
-describe('createDbMetadataChunkStorage', () => {
-  let db: Kysely<TestDb>;
-
-  beforeEach(async () => {
-    db = createDatabase<TestDb>({
-      dialect: createBunSqliteDialect({ path: ':memory:' }),
-      family: 'sqlite',
-    });
-    await ensureSyncSchema(db, createSqliteServerDialect());
-  });
-
-  afterEach(async () => {
-    await db.destroy();
-  });
-
-  it('returns the persisted chunk id on page-key conflicts', async () => {
-    const storage = createDbMetadataChunkStorage({
-      db,
-      blobAdapter: createInMemoryBlobAdapter(),
-    });
-
-    const body = new Uint8Array([1, 2, 3, 4]);
-    const expiresAt = new Date(Date.now() + 60_000).toISOString();
-
-    const first = await storage.storeChunk({
-      partitionId: 'p1',
-      scopeKey: 'scope-key',
-      scope: 'tasks',
-      asOfCommitSeq: 1,
-      rowCursor: null,
-      rowLimit: 100,
-      encoding: 'json-row-frame-v1',
-      compression: 'gzip',
-      sha256: 'chunk-sha',
-      expiresAt,
-      body,
-    });
-
-    const second = await storage.storeChunk({
-      partitionId: 'p1',
-      scopeKey: 'scope-key',
-      scope: 'tasks',
-      asOfCommitSeq: 1,
-      rowCursor: null,
-      rowLimit: 100,
-      encoding: 'json-row-frame-v1',
-      compression: 'gzip',
-      sha256: 'chunk-sha',
-      expiresAt: new Date(Date.now() + 120_000).toISOString(),
-      body,
-    });
-
-    expect(second.id).toBe(first.id);
-
-    const chunkBody = await storage.readChunk(second.id);
-    expect(chunkBody).toEqual(body);
-
-    const countResult = await sql<{ count: number }>`
-      select count(*) as count
-      from ${sql.table('sync_snapshot_chunks')}
-    `.execute(db);
-
-    expect(Number(countResult.rows[0]?.count ?? 0)).toBe(1);
-  });
-
-  it('disables blob checksums for chunk stream writes', async () => {
-    const putStreamMetadata: Array<Record<string, unknown> | undefined> = [];
-    const blobAdapter: BlobStorageAdapter = {
-      name: 'memory-stream',
-      async signUpload() {
-        return { url: 'https://example.test/upload', method: 'PUT' };
-      },
-      async signDownload() {
-        return 'https://example.test/download';
-      },
-      async exists() {
-        return false;
-      },
-      async delete() {},
-      async put() {},
-      async get() {
-        return null;
-      },
-      async putStream(_hash, stream, metadata) {
-        putStreamMetadata.push(metadata);
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done } = await reader.read();
-            if (done) break;
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      },
-    };
-
-    const storage = createDbMetadataChunkStorage({
-      db,
-      blobAdapter,
-    });
-
-    await storage.storeChunkStream({
-      partitionId: 'p1',
-      scopeKey: 'scope-key',
-      scope: 'tasks',
-      asOfCommitSeq: 1,
-      rowCursor: null,
-      rowLimit: 100,
-      encoding: 'json-row-frame-v1',
-      compression: 'gzip',
-      sha256: 'chunk-sha',
-      expiresAt: new Date(Date.now() + 60_000).toISOString(),
-      byteLength: 4,
-      bodyStream: createBodyStream([new Uint8Array([1, 2, 3, 4])]),
-    });
-
-    expect(putStreamMetadata).toHaveLength(1);
-    expect(putStreamMetadata[0]?.disableChecksum).toBe(true);
-  });
-});

package/src/subscriptions/resolve.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { createDatabase } from '@syncular/core';
-import type { Kysely } from 'kysely';
-import { createBunSqliteDialect } from '../../../dialect-bun-sqlite/src';
-import {
-  createServerHandler,
-  createServerHandlerCollection,
-} from '../handlers';
-import type { SyncCoreDb } from '../schema';
-import { createDatabaseScopeCache, createDefaultScopeCacheKey } from './cache';
-import { resolveEffectiveScopesForSubscriptions } from './resolve';
-
-interface TasksTable {
-  id: string;
-  user_id: string;
-  server_version: number;
-}
-
-interface TestDb extends SyncCoreDb {
-  tasks: TasksTable;
-}
-
-interface ClientDb {
-  tasks: TasksTable;
-}
-
-describe('resolveEffectiveScopesForSubscriptions cache behavior', () => {
-  let db: Kysely<TestDb>;
-
-  beforeEach(() => {
-    db = createDatabase<TestDb>({
-      dialect: createBunSqliteDialect({ path: ':memory:' }),
-      family: 'sqlite',
-    });
-  });
-
-  afterEach(async () => {
-    await db.destroy();
-  });
-
-  it('memoizes resolveScopes calls inside a single request', async () => {
-    let resolveCalls = 0;
-    const handler = createServerHandler<TestDb, ClientDb, 'tasks'>({
-      table: 'tasks',
-      scopes: ['user:{user_id}'],
-      resolveScopes: async (ctx) => {
-        resolveCalls += 1;
-        return { user_id: [ctx.actorId] };
-      },
-    });
-    const handlers = createServerHandlerCollection<TestDb>([handler]);
-
-    const resolved = await resolveEffectiveScopesForSubscriptions({
-      db,
-      auth: { actorId: 'u1' },
-      handlers,
-      subscriptions: [
-        { id: 'sub-1', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
-        { id: 'sub-2', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
-      ],
-    });
-
-    expect(resolveCalls).toBe(1);
-    expect(resolved).toHaveLength(2);
-    expect(resolved.every((entry) => entry.status === 'active')).toBe(true);
-  });
-
-  it('uses shared cache hit and skips resolveScopes', async () => {
-    let resolveCalls = 0;
-    let cacheGetCalls = 0;
-    let cacheSetCalls = 0;
-    const handler = createServerHandler<TestDb, ClientDb, 'tasks'>({
-      table: 'tasks',
-      scopes: ['user:{user_id}'],
-      resolveScopes: async (ctx) => {
-        resolveCalls += 1;
-        return { user_id: [ctx.actorId] };
-      },
-    });
-    const handlers = createServerHandlerCollection<TestDb>([handler]);
-
-    const resolved = await resolveEffectiveScopesForSubscriptions({
-      db,
-      auth: { actorId: 'u1' },
-      handlers,
-      scopeCache: {
-        name: 'test-cache',
-        async get() {
-          cacheGetCalls += 1;
-          return { user_id: ['u1'] };
-        },
-        async set() {
-          cacheSetCalls += 1;
-        },
-      },
-      subscriptions: [
-        { id: 'sub-1', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
-      ],
-    });
-
-    expect(resolveCalls).toBe(0);
-    expect(cacheGetCalls).toBe(1);
-    expect(cacheSetCalls).toBe(0);
-    expect(resolved[0]?.status).toBe('active');
-  });
-
-  it('uses request-local memoization even with shared cache misses', async () => {
-    let resolveCalls = 0;
-    let cacheGetCalls = 0;
-    let cacheSetCalls = 0;
-    const handler = createServerHandler<TestDb, ClientDb, 'tasks'>({
-      table: 'tasks',
-      scopes: ['user:{user_id}'],
-      resolveScopes: async (ctx) => {
-        resolveCalls += 1;
-        return { user_id: [ctx.actorId] };
-      },
-    });
-    const handlers = createServerHandlerCollection<TestDb>([handler]);
-
-    const resolved = await resolveEffectiveScopesForSubscriptions({
-      db,
-      auth: { actorId: 'u1' },
-      handlers,
-      scopeCache: {
-        name: 'test-cache',
-        async get() {
-          cacheGetCalls += 1;
-          return null;
-        },
-        async set() {
-          cacheSetCalls += 1;
-        },
-      },
-      subscriptions: [
-        { id: 'sub-1', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
-        { id: 'sub-2', table: 'tasks', scopes: { user_id: 'u1' }, cursor: -1 },
-      ],
-    });
-
-    expect(resolveCalls).toBe(1);
-    expect(cacheGetCalls).toBe(1);
-    expect(cacheSetCalls).toBe(1);
-    expect(resolved).toHaveLength(2);
-    expect(resolved.every((entry) => entry.status === 'active')).toBe(true);
-  });
-
-  it('roundtrips values through database scope cache', async () => {
-    const scopeCache = createDatabaseScopeCache();
-    const auth = { actorId: 'u1', partitionId: 'tenant-1' };
-    const cacheKey = createDefaultScopeCacheKey({ auth, table: 'tasks' });
-    const context = { db, auth, table: 'tasks', cacheKey };
-    const scopes = { user_id: ['u1', 'u2'] };
-
-    await scopeCache.set({ ...context, scopes });
-    const cachedScopes = await scopeCache.get(context);
-
-    expect(cachedScopes).toEqual(scopes);
-  });
-
-  it('expires entries in database scope cache', async () => {
-    let nowMs = Date.now();
-    const scopeCache = createDatabaseScopeCache({
-      ttlMs: 25,
-      now: () => new Date(nowMs),
-    });
-    const auth = { actorId: 'u1', partitionId: 'tenant-1' };
-    const cacheKey = createDefaultScopeCacheKey({ auth, table: 'tasks' });
-    const context = { db, auth, table: 'tasks', cacheKey };
-
-    await scopeCache.set({
-      ...context,
-      scopes: { user_id: ['u1'] },
-    });
-
-    nowMs += 26;
-    const cachedScopes = await scopeCache.get(context);
-    expect(cachedScopes).toBeNull();
-  });
-});