@spooky-sync/core 0.0.1-canary.21 → 0.0.1-canary.211

package/src/modules/crdt/crdt-hydration.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi } from 'vitest';
+import { LoroDoc } from 'loro-crdt';
+import type { SchemaStructure } from '@spooky-sync/query-builder';
+import { CrdtManager } from './index';
+import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
+import type { Logger } from '../../services/logger/index';
+
+// Regression test for the offline-reload formatting-loss class of bug.
+//
+// Repro pattern: app uses `store: 'memory'` for the local SurrealDB (or
+// any scenario where the local row exists without a CRDT snapshot —
+// fresh device, post-sync-down with stale meta, …). On reload, the
+// editor mounts but stays empty until some unrelated edit fires the
+// parent LIVE feed. From the user's POV, formatting is gone.
+//
+// Fix: when `CrdtManager.open` finds no local snapshot, it must fetch
+// the parent row from remote (the snapshot lives inline on the row in
+// the consolidated design) and dispatch its CRDT field. This test pins
+// that behavior across both shapes — `@crdt`-only fields where the
+// snapshot IS the field value, and `@crdt @cursor` fields where the
+// snapshot lives at `<field>.state`.
+
+function silentLogger(): Logger {
+  const noop = () => {};
+  const fake: any = {};
+  fake.info = noop;
+  fake.warn = noop;
+  fake.debug = noop;
+  fake.error = noop;
+  fake.trace = noop;
+  fake.child = () => fake;
+  return fake as Logger;
+}
+
+function singleTableSchema(opts: { cursor?: boolean } = {}): SchemaStructure {
+  return {
+    tables: [
+      {
+        name: 'thread',
+        columns: {
+          body: {
+            type: 'string',
+            optional: false,
+            crdt: 'text',
+            ...(opts.cursor ? { cursor: true } : {}),
+          },
+        },
+        primaryKey: ['id'],
+      },
+    ],
+    relationships: [],
+    backends: {},
+  };
+}
+
+function buildSnapshot(text: string): Uint8Array {
+  const doc = new LoroDoc();
+  doc.getText('text').insert(0, text);
+  return doc.export({ mode: 'snapshot' });
+}
+
+function makeRemote(handlers: {
+  selectRow?: () => unknown;
+}): RemoteDatabaseService {
+  const remote = {
+    query: vi.fn().mockImplementation(async (sql: string) => {
+      if (sql.includes('LIVE SELECT')) return ['live-uuid'];
+      if (sql.includes('SELECT * FROM ONLY')) {
+        return [handlers.selectRow ? handlers.selectRow() : null];
+      }
+      return [];
+    }),
+    getClient: () =>
+      ({
+        liveOf: async () => ({
+          subscribe: () => () => {},
+        }),
+      }) as any,
+    // CrdtManager watches transport events so it can re-issue table LIVEs after
+    // a reconnect. These tests never drop the socket, so a no-op is enough.
+    getStatus: () => 'connected' as const,
+    subscribeConnection: vi.fn().mockReturnValue(() => {}),
+  } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
+  return remote;
+}
+
+describe('CrdtManager.open hydration', () => {
+  it('@crdt-only: fetches the parent row from remote when local is empty', async () => {
+    const remoteSnapshot = buildSnapshot('hello world');
+
+    const local = {
+      query: vi.fn().mockImplementation(async (sql: string) => {
+        if (sql.includes('SELECT VALUE body FROM ONLY')) return [null];
+        return [];
+      }),
+    } satisfies Partial<LocalStore> as unknown as LocalStore;
+
+    const remote = makeRemote({
+      selectRow: () => ({ id: 'thread:abc', body: remoteSnapshot }),
+    });
+
+    const manager = new CrdtManager(singleTableSchema(), local, remote, silentLogger());
+    manager.setSessionId('session-under-test');
+
+    const field = await manager.open('thread', 'thread:abc', 'body');
+
+    await vi.waitFor(() => {
+      expect(field.getDoc().getText('text').toString()).toBe('hello world');
+    });
+
+    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map(
+      (c) => c[0] as string
+    );
+    expect(sqls.some((s) => s.includes('SELECT * FROM ONLY'))).toBe(true);
+  });
+
+  it('@crdt @cursor: extracts the snapshot from the object shape', async () => {
+    const remoteSnapshot = buildSnapshot('object shape');
+
+    const local = {
+      query: vi.fn().mockImplementation(async () => [null]),
+    } satisfies Partial<LocalStore> as unknown as LocalStore;
+
+    // Cursor-enabled field stores `{ state, cursors }`. The remote row
+    // returns this shape; the manager must drill into `.state` for the
+    // snapshot bytes.
+    const remote = makeRemote({
+      selectRow: () => ({
+        id: 'thread:abc',
+        body: { state: remoteSnapshot, cursors: {} },
+      }),
+    });
+
+    const manager = new CrdtManager(
+      singleTableSchema({ cursor: true }),
+      local,
+      remote,
+      silentLogger()
+    );
+    manager.setSessionId('session-under-test');
+
+    const field = await manager.open('thread', 'thread:abc', 'body');
+
+    await vi.waitFor(() => {
+      expect(field.getDoc().getText('text').toString()).toBe('object shape');
+    });
+  });
+
+  it('skips the remote fetch when a local snapshot already exists', async () => {
+    const localSnapshot = buildSnapshot('cached');
+
+    const local = {
+      query: vi.fn().mockImplementation(async (sql: string) => {
+        if (sql.includes('SELECT VALUE body FROM ONLY')) return [localSnapshot];
+        return [];
+      }),
+    } satisfies Partial<LocalStore> as unknown as LocalStore;
+
+    const remote = makeRemote({});
+
+    const manager = new CrdtManager(singleTableSchema(), local, remote, silentLogger());
+    manager.setSessionId('session-under-test');
+
+    const field = await manager.open('thread', 'thread:def', 'body');
+
+    expect(field.getDoc().getText('text').toString()).toBe('cached');
+
+    // Give any stray async work a tick to land before asserting absence.
+    await new Promise((r) => setTimeout(r, 20));
+
+    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map(
+      (c) => c[0] as string
+    );
+    expect(sqls.some((s) => s.includes('SELECT * FROM ONLY'))).toBe(false);
+  });
+
+  // Regression: SurrealDB returns bytes nested inside a FLEXIBLE object as a
+  // plain `number[]` from the local WASM engine (e.g. `state: [108, 111, 114,
+  // 111, ...]` — the literal LoroDoc magic header bytes). The cursor-enabled
+  // extractSnapshot path used to only accept Uint8Array and would silently
+  // return undefined for the array form, leaving every editor empty and
+  // killing realtime updates for `@crdt @cursor` fields.
+  it('@crdt @cursor: accepts number[] as the state shape (local WASM transport)', async () => {
+    const remoteSnapshot = buildSnapshot('from local wasm');
+    const remoteAsArray = Array.from(remoteSnapshot) as unknown as number[];
+
+    const local = {
+      query: vi.fn().mockImplementation(async (sql: string) => {
+        if (sql.includes('SELECT VALUE body FROM ONLY')) {
+          return [{ state: remoteAsArray, cursors: {} }];
+        }
+        return [];
+      }),
+    } satisfies Partial<LocalStore> as unknown as LocalStore;
+
+    const remote = makeRemote({});
+
+    const manager = new CrdtManager(
+      singleTableSchema({ cursor: true }),
+      local,
+      remote,
+      silentLogger()
+    );
+    manager.setSessionId('session-under-test');
+
+    const field = await manager.open('thread', 'thread:wasm', 'body');
+
+    expect(field.getDoc().getText('text').toString()).toBe('from local wasm');
+  });
+});

package/src/modules/crdt/crdt-reconnect.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { SchemaStructure } from '@spooky-sync/query-builder';
+import { CrdtManager } from './index';
+import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
+import type { Logger } from '../../services/logger/index';
+
+// A LIVE subscription lives and dies with its WebSocket session, and
+// `ensureTableSubscription` is memoized on `liveByTable`. Without a reconnect
+// hook, the first dropped socket kills CRDT realtime for good: the map still
+// holds a uuid for a subscription the server has forgotten, so every later
+// `open()` short-circuits and no LIVE is ever re-issued.
+
+const noop = () => {};
+
+/** A promise plus its resolver, so a test can hold an RPC open on demand. */
+function deferred<T>(): { promise: Promise<T>; resolve: (v: T) => void } {
+  let resolve!: (v: T) => void;
+  const promise = new Promise<T>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+function silentLogger(): Logger {
+  const fake: any = {};
+  fake.info = noop;
+  fake.warn = noop;
+  fake.debug = noop;
+  fake.error = noop;
+  fake.trace = noop;
+  fake.child = () => fake;
+  return fake as Logger;
+}
+
+function singleTableSchema(): SchemaStructure {
+  return {
+    tables: [
+      {
+        name: 'thread',
+        columns: { body: { type: 'string', optional: false, crdt: 'text' } },
+        primaryKey: ['id'],
+      },
+    ],
+    relationships: [],
+    backends: {},
+  };
+}
+
+function makeRemote() {
+  const handlers = new Map<string, Array<(...a: any[]) => void>>();
+  const remote = {
+    query: vi.fn().mockImplementation(async (sql: string) => {
+      if (sql.includes('LIVE SELECT')) return ['live-uuid'];
+      if (sql.includes('SELECT * FROM ONLY')) return [null];
+      return [];
+    }),
+    getClient: () =>
+      ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
+    getStatus: () => 'connected' as const,
+    subscribeConnection: (event: string, cb: (...a: any[]) => void) => {
+      handlers.set(event, [...(handlers.get(event) ?? []), cb]);
+      return () => {
+        handlers.set(event, (handlers.get(event) ?? []).filter((h) => h !== cb));
+      };
+    },
+  } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
+  const emit = (event: string) => {
+    for (const cb of Array.from(handlers.get(event) ?? [])) cb();
+  };
+  return { remote, emit };
+}
+
+function makeLocal(): LocalStore {
+  return {
+    query: vi.fn().mockResolvedValue([null]),
+  } satisfies Partial<LocalStore> as unknown as LocalStore;
+}
+
+const liveSelects = (remote: RemoteDatabaseService) =>
+  (remote.query as ReturnType<typeof vi.fn>).mock.calls
+    .map((c) => c[0] as string)
+    .filter((s) => s.includes('LIVE SELECT'));
+
+describe('CrdtManager reconnect', () => {
+  it('re-issues the table LIVE after a recovered drop', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    // The SDK's own reconnect path: `reconnecting` then `connected`, never
+    // `disconnected`.
+    emit('reconnecting');
+    emit('connected');
+
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
+    // No KILL: that uuid belonged to a session that no longer exists.
+    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0] as string);
+    expect(sqls.some((s) => s.includes('KILL'))).toBe(false);
+  });
+
+  it('re-issues the table LIVE after the SDK gives up', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    emit('disconnected');
+    emit('connected');
+
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
+  });
+
+  it('does not resurrect a LIVE for a table whose fields were all closed', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    // A drop can outlive the editor that needed the feed.
+    emit('reconnecting');
+    manager.close('thread', 'thread:abc', 'body');
+    emit('connected');
+
+    await new Promise((r) => setTimeout(r, 10));
+    expect(liveSelects(remote)).toHaveLength(1);
+  });
+
+  it('discards and re-registers a LIVE that was mid-flight when the socket dropped', async () => {
+    const handlers = new Map<string, Array<() => void>>();
+    const firstLive = deferred<void>();
+    let liveCalls = 0;
+    const remote = {
+      query: vi.fn().mockImplementation(async (sql: string) => {
+        if (sql.includes('LIVE SELECT')) {
+          liveCalls++;
+          // Hold the FIRST registration open so the drop lands mid-flight.
+          if (liveCalls === 1) {
+            await firstLive.promise;
+            return ['dead-session-uuid'];
+          }
+          return ['fresh-uuid'];
+        }
+        return [null];
+      }),
+      getClient: () => ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
+      getStatus: () => 'connected' as const,
+      subscribeConnection: (event: string, cb: () => void) => {
+        handlers.set(event, [...(handlers.get(event) ?? []), cb]);
+        return () => {};
+      },
+    } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
+    const emit = (event: string) => {
+      for (const cb of Array.from(handlers.get(event) ?? [])) cb();
+    };
+
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveCalls).toBe(1));
+
+    // Drop + recover while the first registration is still awaiting its uuid.
+    emit('reconnecting');
+    emit('connected');
+    firstLive.resolve();
+
+    // The doomed uuid must never be recorded — if it were, `liveByTable` would
+    // short-circuit every future restart and CRDT realtime would be dead for
+    // good. A fresh registration must take its place.
+    await vi.waitFor(() => expect(liveCalls).toBe(2));
+    expect((manager as any).liveByTable.get('thread')).toBe('fresh-uuid');
+  });
+
+  it('stops reacting to transport events after dispose', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    manager.dispose();
+    emit('reconnecting');
+    emit('connected');
+
+    await new Promise((r) => setTimeout(r, 10));
+    expect(liveSelects(remote)).toHaveLength(1);
+  });
+});