@spooky-sync/core 0.0.1-canary.326 → 0.0.1-canary.328

package/src/services/database/local.test.ts

@@ -62,3 +62,89 @@ describe('matchesBucketStore', () => {
     expect(matchesBucketStore('sp00ky', 'sp00ky-anon')).toBe(false);
   });
 });
+
+// A bucket switch that lands while the boot open is still in flight (a reload
+// of a signed-in tab, with IndexedDB slow to open) must wait for it. Run
+// concurrently, the switch closed the client `connect` was opening and both
+// provisioned a store at once, so boot never finished.
+import { vi } from 'vitest';
+import { Surreal } from 'surrealdb';
+import { LocalDatabaseService } from './local';
+
+vi.mock('@surrealdb/wasm', () => ({ createWasmWorkerEngines: () => ({}) }));
+
+describe('LocalDatabaseService open and switch', () => {
+  it('a switch waits for the in-flight connect instead of closing the client it opens', async () => {
+    const opens: Array<{ url: string; done: () => void }> = [];
+    const closed: string[] = [];
+    const urlOf = new WeakMap<object, string>();
+    vi.spyOn(Surreal.prototype, 'connect').mockImplementation(function (this: Surreal, url: string | URL) {
+      urlOf.set(this, String(url));
+      return new Promise<true>((resolve) => opens.push({ url: String(url), done: () => resolve(true) }));
+    });
+    vi.spyOn(Surreal.prototype, 'use').mockResolvedValue({});
+    vi.spyOn(Surreal.prototype, 'close').mockImplementation(async function (this: Surreal) {
+      closed.push(urlOf.get(this) ?? 'placeholder');
+      return true as const;
+    });
+    const logger: any = { trace: vi.fn(), debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    logger.child = () => logger;
+    const local = new LocalDatabaseService({ namespace: 'n', database: 'd', store: 'indexeddb' } as any, logger);
+
+    const booting = local.connect('u1');
+    await vi.waitFor(() => expect(opens).toHaveLength(1));
+    const switching = local.switchStore('anon');
+    await new Promise((r) => setTimeout(r, 10));
+    expect(opens.map((o) => o.url)).toEqual(['indxdb://sp00ky-u1']);
+    expect(closed).toEqual([]);
+
+    opens[0].done();
+    await booting;
+    await vi.waitFor(() => expect(opens).toHaveLength(2));
+    expect(opens[1].url).toBe('indxdb://sp00ky-anon');
+    opens[1].done();
+    await switching;
+    expect(closed).toEqual(['indxdb://sp00ky-u1']);
+    expect(local.currentBucketId).toBe('anon');
+    vi.restoreAllMocks();
+  });
+
+  // The engine streams a statement's result from its worker; closing the
+  // client under it left the statement pending until its 30 s deadline, and
+  // every later local statement queued behind it (sign-in hung on "Loading").
+  it.each(['memory', 'indexeddb'] as const)('%s: a switch lets a statement in flight finish before it closes the client', async (store) => {
+    let answer!: (rows: unknown[]) => void;
+    const events: string[] = [];
+    vi.spyOn(Surreal.prototype, 'connect').mockResolvedValue(true);
+    vi.spyOn(Surreal.prototype, 'use').mockResolvedValue({});
+    vi.spyOn(Surreal.prototype, 'query').mockImplementation((() =>
+      new Promise((r) => {
+        answer = (rows) => {
+          events.push('answered');
+          r(rows);
+        };
+      })) as any);
+    vi.spyOn(Surreal.prototype, 'close').mockImplementation(async () => {
+      events.push('close');
+      return true as const;
+    });
+    const logger: any = { trace: vi.fn(), debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    logger.child = () => logger;
+    const local = new LocalDatabaseService({ namespace: 'n', database: 'd', store } as any, logger);
+    await local.connect('anon');
+
+    const reading = local.query('SELECT * FROM thing');
+    await vi.waitFor(() => expect(answer).toBeDefined());
+    const release = local.beginSwitch();
+    const switching = local.switchStore('u1');
+    await new Promise((r) => setTimeout(r, 10));
+    expect(events).toEqual([]);
+
+    answer([[]]);
+    await reading;
+    await switching;
+    release();
+    expect(events).toEqual(['answered', 'close']);
+    vi.restoreAllMocks();
+  });
+});

package/src/services/database/local.ts

@@ -104,6 +104,8 @@ export class LocalDatabaseService extends AbstractDatabaseService {
   private gate: Promise<void> = Promise.resolve();
   /** The incoming client while a switch is in flight (for unload cleanup). */
   private pendingSwitchClient: Surreal | null = null;
+  /** The open `connect()` started, until it settles. */
+  private opening: Promise<void> | null = null;
 
   constructor(config: Sp00kyConfig<any>['database'], logger: Logger) {
     const events = createDatabaseEventSystem();
@@ -176,6 +178,16 @@ export class LocalDatabaseService extends AbstractDatabaseService {
   }
 
   async connect(bucketId: string = ANON_USER_ID): Promise<void> {
+    const opening = this.openBucket(bucketId);
+    this.opening = opening;
+    try {
+      await opening;
+    } finally {
+      if (this.opening === opening) this.opening = null;
+    }
+  }
+
+  private async openBucket(bucketId: string): Promise<void> {
     const { namespace, database } = this.getConfig();
     const store = this.getConfig().store ?? 'memory';
     this.bucketId = bucketId;
@@ -201,9 +213,16 @@ export class LocalDatabaseService extends AbstractDatabaseService {
    * async chains can detect they're stale.
    *
    * Callers own the drain/rebind choreography (close the gate, quiesce sync +
-   * timers BEFORE calling this; re-provision + rebind AFTER).
+   * timers BEFORE calling this; re-provision + rebind AFTER). Statements that
+   * passed the gate before it closed are let finish before the old client
+   * closes: the engine streams results from its worker, and a client closed
+   * under a statement leaves that statement pending until its deadline, with
+   * every later local statement queued behind it.
    */
   async switchStore(bucketId: string): Promise<void> {
+    // Never overlap the boot open: the switch would close the client `connect`
+    // is still opening, and both would provision a store at once.
+    if (this.opening) await this.opening.catch(() => {});
     if (bucketId === this.bucketId) return;
     const { namespace, database } = this.getConfig();
     const store = this.getConfig().store ?? 'memory';
@@ -212,6 +231,7 @@ export class LocalDatabaseService extends AbstractDatabaseService {
     if (store === 'memory') {
       // mem:// has no per-user persistence; close + reopen the same client
       // yields a fresh empty store, which is exactly the reset we want.
+      await this.drainStatements();
       try {
         await this.client.close();
       } catch {
@@ -241,6 +261,7 @@ export class LocalDatabaseService extends AbstractDatabaseService {
       this.pendingSwitchClient = null;
     }
 
+    await this.drainStatements();
     const old = this.client;
     this.client = next;
     this.bucketId = bucketId;

package/src/services/database/sqlite-cache-engine.test.ts

@@ -556,6 +556,17 @@ describe('create() tx result shaping (fast path parity)', () => {
     expect(outboxRow.mutationType).toBe('create');
     expect(outboxRow.data).toEqual(payload);
   });
+
+  // A raw query with a field list materializes from its id-set as
+  // `FROM (SELECT * FROM $__win)` (the wasm SurrealDB throws on a field list
+  // over bare record ids). This engine reads both shapes the same way.
+  it('reads a field list over a wrapped id-set like the bare one', () => {
+    const ids = ['_00_user_feature:a', '_00_user_feature:b'];
+    const bare = translateSurql('SELECT key, variant FROM $__win', { __win: ids }).ops[0];
+    const wrapped = translateSurql('SELECT key, variant FROM (SELECT * FROM $__win)', { __win: ids }).ops[0];
+    expect(wrapped).toEqual(bare);
+    expect(wrapped).toMatchObject({ kind: 'selectByIds', ids });
+  });
 });
 
 

package/src/services/database/surql-translate.ts

@@ -193,13 +193,14 @@ function translateStatement(stmt: string, vars: Record<string, unknown>): SqlOp
     return { kind: 'getById', id: idOperand(m[3], vars), select: projFields(m[2], !!m[1]), value };
   }
 
-  // SELECT [VALUE] <proj> FROM $arrayParam
-  m = /^SELECT\s+(VALUE\s+)?(.+?)\s+FROM\s+\$(\w+)$/i.exec(head);
+  // SELECT [VALUE] <proj> FROM $arrayParam, or FROM (SELECT * FROM $arrayParam)
+  // (the id-set read's shape for a field list, see `idSetSource`).
+  m = /^SELECT\s+(VALUE\s+)?(.+?)\s+FROM\s+(?:\$(\w+)|\(\s*SELECT\s+\*\s+FROM\s+\$(\w+)\s*\))$/i.exec(head);
   if (m) {
     const value = m[1] ? m[2].trim() : undefined;
     return {
       kind: 'selectByIds',
-      ids: (vars[m[3]] as unknown[]) ?? [],
+      ids: (vars[m[3] ?? m[4]] as unknown[]) ?? [],
       select: projFields(m[2], !!m[1]),
       value,
       limit,

package/src/services/database/surreal-cache-engine.ts

@@ -69,7 +69,9 @@ export class SurrealCacheEngine extends LocalDatabaseService implements LocalCac
     if (ids.length === 0) return [];
     const projection =
       opts?.select && opts.select.length > 0 ? ['id', ...opts.select].join(', ') : '*';
-    let sql = `SELECT ${projection} FROM $__ids`;
+    // As documents: over bare record ids the wasm engine throws on a field
+    // list and ignores ORDER BY (see `idSetSource`).
+    let sql = `SELECT ${projection} FROM (SELECT * FROM $__ids)`;
     if (opts?.orderBy && opts.orderBy.length > 0) {
       sql += ` ORDER BY ${opts.orderBy.map(([f, d]) => `${f} ${d}`).join(', ')}`;
     }

package/src/state/selectors.ts

@@ -79,6 +79,30 @@ export function retained(s: ClientState): (id: string) => boolean {
   return (id) => id.startsWith('_00_') || known.has(id) || held.has(id);
 }
 
+/**
+ * Ids something live still needs: a mounted query's membership or subquery
+ * children, or a local write not yet settled. Unlike `retained`, durable view
+ * rows of queries nobody runs right now do not count: a row the server just
+ * took out of a live query must stop showing even if an old view named it.
+ */
+export function activelyHeld(s: ClientState): ReadonlySet<string> {
+  const held = new Set<string>();
+  for (const e of s.queries.values()) {
+    for (const [id] of e.remoteArray) held.add(id);
+    for (const [id] of e.subqueryRemoteArray) held.add(id);
+  }
+  for (const item of s.outbox) held.add(item.recordId);
+  for (const write of s.pendingWrites.values()) held.add(write.recordId);
+  return held;
+}
+
+/** Ids of `before` that `after` no longer names. */
+export function departedIds(before: RecordVersionArray, after: RecordVersionArray): string[] {
+  if (before.length === 0) return [];
+  const kept = new Set(after.map(([id]) => id));
+  return before.filter(([id]) => !kept.has(id)).map(([id]) => id);
+}
+
 export const pendingDeleteIds = (s: ClientState): ReadonlySet<string> =>
   new Set(s.outbox.filter((i) => i.type === 'delete').map((i) => i.recordId));
 

package/src/testing/fake-services.ts

@@ -38,7 +38,22 @@ export function fakeServiceBundle<S extends SchemaStructure>(over: Partial<Servi
     streamProcessor: { addReceiver: (r: unknown) => void receivers.push(r), checkpoint: async () => undefined, dispose: noop } as any,
     migrator: {} as any,
     crdt: { attach: noop, setSessionId: noop, closeAll: noop, dispose: noop, open: async () => 'field', close: async () => {} } as any,
-    auth: { subscribe: (cb: (u: string | null) => void) => (authListeners.push(cb), noop), subscribeImpersonation: () => noop, onBeforeSignOut: () => noop, currentUser: null, isAuthenticated: false, token: null, impersonation: null, eventSystem: { subscribe: noop } } as any,
+    // Mirrors `AuthService.subscribe`: the current (signed-out) identity at
+    // once unless the subscriber opts out, then every change.
+    auth: {
+      subscribe: (cb: (u: string | null) => void, opts: { immediate?: boolean } = {}) => {
+        if (opts.immediate !== false) cb(null);
+        authListeners.push(cb);
+        return noop;
+      },
+      subscribeImpersonation: () => noop,
+      onBeforeSignOut: () => noop,
+      currentUser: null,
+      isAuthenticated: false,
+      token: null,
+      impersonation: null,
+      eventSystem: { subscribe: noop },
+    } as any,
     tabs: null,
     tabsUnsupportedReason: 'test',
     tabId: 'tab-test',