@spooky-sync/core 0.0.1-canary.240 → 0.0.1-canary.241

package/src/modules/data/data.authority.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { RecordId } from 'surrealdb';
-import { DataModule } from './index';
-import type { QueryState } from '../../types';
-
-/**
- * A query's AUTHORITY is whether server membership is known for it. It is what
- * the bindings' `isAuthoritative()` mirrors, and with `hasData` it is what
- * separates "cold, still waiting for the server" from "the server answered and
- * the answer is empty". `setMembershipKnown` is the one writer; it fans out to
- * `subscribeAuthority` listeners and the DevTools hook only on a change.
- */
-
-function makeLogger(): any {
-  const noop = () => {};
-  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
-  logger.child = () => logger;
-  return logger;
-}
-
-function makeDataModule(): DataModule<any> {
-  return new DataModule(
-    { unregisterQuery: vi.fn() } as any,
-    {} as any,
-    { tables: [] } as any,
-    makeLogger(),
-    100
-  );
-}
-
-function makeQueryState(hash: string, membershipKnown?: boolean): QueryState {
-  return {
-    config: {
-      id: new RecordId('_00_query', hash),
-      surql: 'SELECT * FROM user',
-      params: {},
-      localArray: [],
-      remoteArray: [],
-      membershipKnown,
-      ttl: '10m',
-      lastActiveAt: new Date(),
-      tableName: 'user',
-    },
-    records: [],
-    ttlTimer: null,
-    ttlDurationMs: 0,
-    updateCount: 0,
-    lastUpdatedAt: null,
-    materializationSamples: [],
-    lastIngestLatencyMs: null,
-    errorCount: 0,
-    status: 'idle',
-    phaseSamples: {},
-    phaseLast: {},
-    registrationTimings: { parseMs: null, planMs: null, snapshotMs: null, wallMs: null },
-  };
-}
-
-describe('DataModule query authority', () => {
-  const hash = 'h1';
-
-  it('reports the current value immediately, false for an unknown query', () => {
-    const dm = makeDataModule();
-    const unknown = vi.fn();
-    dm.subscribeAuthority('nope', unknown, { immediate: true });
-    expect(unknown).toHaveBeenCalledWith(false);
-
-    (dm as any).activeQueries.set(hash, makeQueryState(hash, true));
-    const known = vi.fn();
-    dm.subscribeAuthority(hash, known, { immediate: true });
-    expect(known).toHaveBeenCalledWith(true);
-    expect(dm.isAuthoritative(hash)).toBe(true);
-    expect(dm.isAuthoritative('nope')).toBe(false);
-  });
-
-  it('emits once per transition through the single writer', () => {
-    const dm = makeDataModule();
-    (dm as any).activeQueries.set(hash, makeQueryState(hash));
-    const cb = vi.fn();
-    const hook = vi.fn();
-    dm.onQueryAuthorityChange = hook;
-    dm.subscribeAuthority(hash, cb);
-
-    (dm as any).setMembershipKnown(hash, true);
-    (dm as any).setMembershipKnown(hash, true);
-    expect(cb).toHaveBeenCalledTimes(1);
-    expect(cb).toHaveBeenLastCalledWith(true);
-    expect(hook).toHaveBeenCalledWith(hash, true);
-
-    (dm as any).setMembershipKnown(hash, false);
-    expect(cb).toHaveBeenCalledTimes(2);
-    expect(cb).toHaveBeenLastCalledWith(false);
-    expect(dm.isAuthoritative(hash)).toBe(false);
-  });
-
-  it('is a no-op for an unknown query', () => {
-    const dm = makeDataModule();
-    const hook = vi.fn();
-    dm.onQueryAuthorityChange = hook;
-    (dm as any).setMembershipKnown('nope', true);
-    expect(hook).not.toHaveBeenCalled();
-  });
-
-  it('stops delivering after unsubscribe', () => {
-    const dm = makeDataModule();
-    (dm as any).activeQueries.set(hash, makeQueryState(hash));
-    const cb = vi.fn();
-    const off = dm.subscribeAuthority(hash, cb);
-    off();
-    (dm as any).setMembershipKnown(hash, true);
-    expect(cb).not.toHaveBeenCalled();
-    expect((dm as any).authoritySubscriptions.has(hash)).toBe(false);
-  });
-
-  it('drops the authority subscribers with the query on finalizeDeregister', () => {
-    const dm = makeDataModule();
-    (dm as any).activeQueries.set(hash, makeQueryState(hash));
-    dm.subscribeAuthority(hash, vi.fn());
-    dm.finalizeDeregister(hash);
-    expect((dm as any).authoritySubscriptions.has(hash)).toBe(false);
-  });
-});

package/src/modules/data/data.heartbeat-wake.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { RecordId } from 'surrealdb';
-import { DataModule } from './index';
-import type { QueryState } from '../../types';
-
-/**
- * The TTL heartbeat is the only thing keeping a view alive on the server, and
- * browsers freeze timers in hidden tabs. `heartbeatOnWake` re-asserts liveness
- * for every WATCHED query the moment the tab is back (visibilitychange /
- * online) and re-anchors its timer. There is no client-side expiry anywhere:
- * the TTL belongs to the server.
- */
-
-function makeLogger(): any {
-  const noop = () => {};
-  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
-  logger.child = () => logger;
-  return logger;
-}
-
-function makeDataModule(): DataModule<any> {
-  return new DataModule({} as any, {} as any, { tables: [] } as any, makeLogger(), 100);
-}
-
-const TTL_MS = 600_000;
-
-function makeQueryState(hash: string): QueryState {
-  return {
-    config: {
-      id: new RecordId('_00_query', hash),
-      surql: 'SELECT * FROM user',
-      params: {},
-      localArray: [],
-      remoteArray: [['user:a', 1]],
-      membershipKnown: true,
-      ttl: '10m',
-      lastActiveAt: new Date(),
-      tableName: 'user',
-    },
-    records: [{ id: 'user:a' }],
-    ttlTimer: null,
-    ttlDurationMs: TTL_MS,
-    updateCount: 0,
-    lastUpdatedAt: null,
-    materializationSamples: [],
-    lastIngestLatencyMs: null,
-    errorCount: 0,
-    status: 'idle',
-    phaseSamples: {},
-    phaseLast: {},
-    registrationTimings: { parseMs: null, planMs: null, snapshotMs: null, wallMs: null },
-  };
-}
-
-function setup() {
-  const dm = makeDataModule();
-  const onHeartbeat = vi.fn();
-  dm.onHeartbeat = onHeartbeat;
-  const watched = makeQueryState('watched');
-  const idle = makeQueryState('idle');
-  (dm as any).activeQueries.set('watched', watched);
-  (dm as any).activeQueries.set('idle', idle);
-  (dm as any).subscriptions.set('watched', new Set([() => {}]));
-  (dm as any).startTTLHeartbeat(watched, 'watched');
-  (dm as any).startTTLHeartbeat(idle, 'idle');
-  return { dm, onHeartbeat, watched, idle };
-}
-
-describe('DataModule heartbeat on wake', () => {
-  beforeEach(() => vi.useFakeTimers());
-  afterEach(() => vi.useRealTimers());
-
-  it('beats every watched query now and re-anchors its timer', async () => {
-    const { dm, onHeartbeat, watched } = setup();
-    await vi.advanceTimersByTimeAsync(200_000);
-
-    expect(dm.heartbeatOnWake()).toBe(1);
-    expect(onHeartbeat).toHaveBeenCalledTimes(1);
-    expect(onHeartbeat).toHaveBeenCalledWith('watched');
-    expect(watched.ttlTimer).not.toBeNull();
-
-    // The regular beat would have been due at 300s; it is now due 300s after
-    // the wake beat instead.
-    await vi.advanceTimersByTimeAsync(TTL_MS / 2 - 1_000);
-    expect(onHeartbeat).toHaveBeenCalledTimes(1);
-    await vi.advanceTimersByTimeAsync(2_000);
-    expect(onHeartbeat).toHaveBeenCalledTimes(2);
-  });
-
-  it('skips queries nobody is watching', () => {
-    const { dm, onHeartbeat } = setup();
-    dm.heartbeatOnWake();
-    expect(onHeartbeat).not.toHaveBeenCalledWith('idle');
-  });
-
-  it('does not beat the same query twice within the gap', async () => {
-    const { dm, onHeartbeat } = setup();
-    expect(dm.heartbeatOnWake()).toBe(1);
-    expect(dm.heartbeatOnWake()).toBe(0);
-    await vi.advanceTimersByTimeAsync(31_000);
-    expect(dm.heartbeatOnWake()).toBe(1);
-    expect(onHeartbeat).toHaveBeenCalledTimes(2);
-  });
-
-  it('never expires local query state on its own', async () => {
-    const { dm, watched, idle } = setup();
-    // Well past the TTL, with no server in the picture.
-    await vi.advanceTimersByTimeAsync(TTL_MS * 3);
-    expect((dm as any).activeQueries.get('watched')).toBe(watched);
-    expect((dm as any).activeQueries.get('idle')).toBe(idle);
-    expect(watched.records).toEqual([{ id: 'user:a' }]);
-    expect(watched.config.remoteArray).toEqual([['user:a', 1]]);
-    expect(watched.config.membershipKnown).toBe(true);
-  });
-});

package/src/modules/data/data.hydration.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { RecordId } from 'surrealdb';
-import { DataModule } from './index';
-import type { QueryState } from '../../types';
-
-/**
- * Tests for instant-hydrate's DataModule half: `applyHydration` — run-once,
- * remoteArray priming, subscriber notify, and the epoch guard added when the
- * hydrate fetch moved off the paint path into a background chain.
- */
-
-function makeLogger(): any {
-  const noop = () => {};
-  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
-  logger.child = () => logger;
-  return logger;
-}
-
-function makeQueryState(hash: string): QueryState {
-  return {
-    config: {
-      id: new RecordId('_00_query', hash),
-      surql: 'SELECT * FROM user',
-      params: {},
-      localArray: [],
-      remoteArray: [],
-      ttl: '10m',
-      lastActiveAt: new Date(),
-      tableName: 'user',
-    },
-    records: [],
-    ttlTimer: null,
-    ttlDurationMs: 0,
-    updateCount: 0,
-    lastUpdatedAt: null,
-    materializationSamples: [],
-    lastIngestLatencyMs: null,
-    errorCount: 0,
-    status: 'fetching',
-    phaseSamples: {},
-    phaseLast: {},
-    registrationTimings: { parseMs: null, planMs: null, snapshotMs: null, wallMs: null },
-  };
-}
-
-const schema = { tables: [{ name: 'user', columns: {} }] } as any;
-
-function makeRow(id: string, rv = 1) {
-  return { id: new RecordId('user', id), name: id, _00_rv: rv };
-}
-
-describe('DataModule.applyHydration', () => {
-  const hash = 'h1';
-
-  function setup({ epochFlipsOnSave = false } = {}) {
-    let epoch = 1;
-    const saved: any[] = [];
-    const cache: any = {
-      saveBatch: async (batch: any[]) => {
-        saved.push(...batch);
-        if (epochFlipsOnSave) epoch = 2;
-      },
-    };
-    const local: any = {
-      get epoch() {
-        return epoch;
-      },
-      query: async () => [[makeRow('a')]],
-    };
-    const dm = new DataModule(cache, local, schema, makeLogger(), 100);
-    const state = makeQueryState(hash);
-    (dm as any).activeQueries.set(hash, state);
-    return { dm, state, saved };
-  }
-
-  it('primes remoteArray, materializes and notifies subscribers', async () => {
-    const { dm, state, saved } = setup();
-    const emissions: any[] = [];
-    dm.subscribe(hash, (records) => emissions.push(records));
-
-    await dm.applyHydration(hash, [makeRow('a', 3)]);
-
-    expect(state.hydrated).toBe(true);
-    expect(state.config.remoteArray).toEqual([['user:a', 3]]);
-    expect(saved.length).toBe(1);
-    expect(emissions.length).toBe(1);
-    expect(dm.isCold(hash)).toBe(false);
-  });
-
-  it('runs once even when the remote returns nothing (hydrated flag)', async () => {
-    const { dm, state, saved } = setup();
-    await dm.applyHydration(hash, []);
-    expect(state.hydrated).toBe(true);
-    expect(saved).toEqual([]);
-    expect(dm.isCold(hash)).toBe(false); // hydrated → no longer cold
-  });
-
-  it('is a no-op for an unknown query', async () => {
-    const { dm, saved } = setup();
-    await dm.applyHydration('nope', [makeRow('a')]);
-    expect(saved).toEqual([]);
-  });
-
-  it('bails before mutating state when the bucket epoch moves mid-persist', async () => {
-    const { dm, state } = setup({ epochFlipsOnSave: true });
-    const emissions: any[] = [];
-    dm.subscribe(hash, (records) => emissions.push(records));
-
-    await dm.applyHydration(hash, [makeRow('a', 3)]);
-
-    // Rows fetched under the previous auth context must not prime the new
-    // bucket's query state — the rebind's re-registration refills it.
-    expect(state.config.remoteArray).toEqual([]);
-    expect(state.records).toEqual([]);
-    expect(emissions).toEqual([]);
-  });
-});
-
-describe('DataModule.getPreloadMarker', () => {
-  function makeDm(getById: (table: string, id: unknown) => Promise<any>) {
-    const local: any = { getById };
-    return new DataModule({} as any, local, schema, makeLogger(), 100);
-  }
-
-  it('returns the marker fields for a real row', async () => {
-    const dm = makeDm(async () => ({ fetchedAt: 123, rowCount: 5 }));
-    expect(await dm.getPreloadMarker('h')).toEqual({ fetchedAt: 123, rowCount: 5 });
-  });
-
-  it('returns null on a miss and on a non-object echo (SurrealDB string quirk)', async () => {
-    expect(await makeDm(async () => null).getPreloadMarker('h')).toBeNull();
-    // `FROM ONLY <string>` used to echo the id string back — must not read as warm.
-    expect(await makeDm(async () => 'h' as any).getPreloadMarker('h')).toBeNull();
-  });
-
-  it('returns null when the read throws', async () => {
-    const dm = makeDm(async () => {
-      throw new Error('boom');
-    });
-    expect(await dm.getPreloadMarker('h')).toBeNull();
-  });
-});