@spooky-sync/core 0.0.1-canary.132 → 0.0.1-canary.133

package/dist/index.js

@@ -1693,9 +1693,14 @@ var SqliteCacheEngine = class {
 			});
 		});
 	}
-	async connect(bucketId) {
+	/**
+	* Spawn the worker and open `bucketId`'s DB. Uses {@link rawCall} (NOT
+	* {@link call}) so it can run as the body of an already-queued opQueue entry
+	* without re-queuing onto itself. Callers must run it through the opQueue.
+	*/
+	async openInternal(bucketId) {
 		this.worker = this.spawnWorker();
-		const { persisted } = await this.call("open", {
+		const { persisted } = await this.rawCall("open", {
 			dbName: bucketId,
 			useOpfs: this.useOpfs
 		});
@@ -1707,16 +1712,28 @@ var SqliteCacheEngine = class {
 			Category: "sp00ky-client::SqliteCacheEngine::connect"
 		}, persisted ? "SQLite OPFS store opened" : "SQLite in-memory store opened (no OPFS)");
 	}
+	/** Enqueue `fn` as a single serialized opQueue entry (mirrors {@link call}'s
+	*  chaining) so it can't interleave with reads/writes at the worker. */
+	enqueue(fn) {
+		const result = this.opQueue.then(fn, fn);
+		this.opQueue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async connect(bucketId) {
+		await this.enqueue(() => this.openInternal(bucketId));
+	}
 	async switchBucket(bucketId) {
 		this.storeEpoch++;
-		if (this.worker) {
-			try {
-				await this.call("close");
-			} catch {}
-			this.worker.terminate();
-			this.worker = null;
-		}
-		await this.connect(bucketId);
+		await this.enqueue(async () => {
+			if (this.worker) {
+				try {
+					await this.rawCall("close");
+				} catch {}
+				this.worker.terminate();
+				this.worker = null;
+			}
+			await this.openInternal(bucketId);
+		});
 	}
 	async close() {
 		if (!this.worker) return;
@@ -5131,8 +5148,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.132";
-const WASM_VERSION = "0.0.1-canary.132";
+const CORE_VERSION = "0.0.1-canary.133";
+const WASM_VERSION = "0.0.1-canary.133";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.132",
+  "version": "0.0.1-canary.133",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,8 +59,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.132",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.132",
+    "@spooky-sync/query-builder": "0.0.1-canary.133",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.133",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

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

@@ -1,10 +1,98 @@
 import { describe, it, expect } from 'vitest';
 import { RecordId } from 'surrealdb';
-import { pureWriteOpResult } from './sqlite-cache-engine';
+import { pureWriteOpResult, SqliteCacheEngine } from './sqlite-cache-engine';
 import { translateSurql } from './surql-translate';
 import type { SqlOp } from './surql-translate';
 import { surql } from '../../utils/surql';
 
+function makeLogger(): any {
+  const noop = () => {};
+  const l: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  l.child = () => l;
+  return l;
+}
+
+/**
+ * A fake Worker that models the real SQLite worker's open/closed lifecycle:
+ * `open` opens the DB, `close` closes it, and `exec`/`run` REJECT with
+ * "sqlite: DB not open" when the DB isn't currently open — exactly the failure
+ * the fix targets. Records every message `type` (across worker generations) so
+ * tests can also inspect dispatch order.
+ */
+class FakeWorker {
+  onmessage: ((ev: any) => void) | null = null;
+  onerror: any = null;
+  onmessageerror: any = null;
+  private dbOpen = false;
+  constructor(private log: string[]) {}
+  postMessage(msg: any) {
+    this.log.push(msg.type);
+    Promise.resolve().then(() => {
+      let ok = true;
+      let error: string | undefined;
+      let rest: Record<string, unknown> = {};
+      if (msg.type === 'open') {
+        this.dbOpen = true;
+        rest = { persisted: true };
+      } else if (msg.type === 'close') {
+        this.dbOpen = false;
+      } else if (msg.type === 'exec') {
+        if (!this.dbOpen) { ok = false; error = 'sqlite: DB not open'; }
+        else rest = { rows: [] };
+      } else if (msg.type === 'run' || msg.type === 'batch') {
+        if (!this.dbOpen) { ok = false; error = 'sqlite: DB not open'; }
+      }
+      this.onmessage?.({ data: { id: msg.id, ok, error, ...rest } });
+    });
+  }
+  terminate() {}
+}
+
+// Regression: switchBucket must run close → reopen as a single serialized
+// opQueue entry. Otherwise a read/write enqueued during an auth/bucket change
+// dispatches to the just-closed worker → "sqlite: DB not open" (the crash on
+// sign-in). The invariant: no `exec` may appear between a `close` and the next
+// `open` in the message stream.
+describe('SqliteCacheEngine.switchBucket serialization', () => {
+  it('never dispatches an op to a closed DB during a bucket switch', async () => {
+    const log: string[] = [];
+    const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger());
+    // Replicate the real spawnWorker's onmessage wiring (resolve/reject pending).
+    (engine as any).spawnWorker = () => {
+      const w = new FakeWorker(log);
+      w.onmessage = (ev: any) => {
+        const { id, ok, error, ...rest } = ev.data ?? {};
+        const p = (engine as any).pending.get(id);
+        if (!p) return;
+        (engine as any).pending.delete(id);
+        if (ok) p.resolve(rest);
+        else p.reject(new Error(error));
+      };
+      return w as unknown as Worker;
+    };
+
+    await engine.connect('anon');
+    expect(log).toContain('open');
+
+    // Fire a switch and a concurrent read (exactly what the sign-in query
+    // re-registration does). With the old non-atomic switch the read's `exec`
+    // dispatched to the closed/terminated worker and REJECTED ("sqlite: DB not
+    // open" / "not connected") — the uncaught crash. The atomic switch makes the
+    // read wait for the reopen and resolve against the new bucket.
+    const switching = engine.switchBucket('user:abc');
+    const reading = engine.getById('_00_query', 'h1');
+    await expect(Promise.all([switching, reading])).resolves.toBeDefined();
+    await expect(reading).resolves.toBeNull(); // missing row → null, not a throw
+
+    // And the close→reopen ran with no op wedged between them.
+    const closeIdx = log.indexOf('close');
+    const openAfter = log.indexOf('open', closeIdx + 1);
+    expect(openAfter).toBeGreaterThan(closeIdx);
+    expect(log.slice(closeIdx + 1, openAfter)).not.toContain('exec');
+    expect(engine.currentBucketId).toBe('user:abc');
+  });
+});
+
 // `pureWriteOpResult` is the single source of truth for what a pure-write op
 // contributes to a query's per-statement results. The batched fast path in
 // `query()` and the per-op `execOp` path BOTH route through it, so a caller that

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

@@ -185,9 +185,14 @@ export class SqliteCacheEngine implements LocalStore {
     });
   }
 
-  async connect(bucketId: string): Promise<void> {
+  /**
+   * Spawn the worker and open `bucketId`'s DB. Uses {@link rawCall} (NOT
+   * {@link call}) so it can run as the body of an already-queued opQueue entry
+   * without re-queuing onto itself. Callers must run it through the opQueue.
+   */
+  private async openInternal(bucketId: string): Promise<void> {
     this.worker = this.spawnWorker();
-    const { persisted } = await this.call<{ persisted: boolean }>('open', {
+    const { persisted } = await this.rawCall<{ persisted: boolean }>('open', {
       dbName: bucketId,
       useOpfs: this.useOpfs,
     });
@@ -199,18 +204,43 @@ export class SqliteCacheEngine implements LocalStore {
     );
   }
 
+  /** Enqueue `fn` as a single serialized opQueue entry (mirrors {@link call}'s
+   *  chaining) so it can't interleave with reads/writes at the worker. */
+  private enqueue<T>(fn: () => Promise<T>): Promise<T> {
+    const result = this.opQueue.then(fn, fn);
+    this.opQueue = result.then(
+      () => undefined,
+      () => undefined
+    );
+    return result;
+  }
+
+  async connect(bucketId: string): Promise<void> {
+    // Serialize through the opQueue so an op racing boot can't dispatch to a
+    // half-open worker.
+    await this.enqueue(() => this.openInternal(bucketId));
+  }
+
   async switchBucket(bucketId: string): Promise<void> {
     this.storeEpoch++;
-    if (this.worker) {
-      try {
-        await this.call('close');
-      } catch {
-        /* ignore */
+    // Run close → terminate → reopen as ONE opQueue entry. Previously `close`
+    // and the new `open` were separate entries, so a query's `exec` (e.g. the
+    // query re-registration fired by an auth/bucket change) could slot in
+    // between and dispatch to the just-closed worker → "sqlite: DB not open".
+    // As a single entry, every other op runs fully before the close or after
+    // the reopen — never against a closed DB.
+    await this.enqueue(async () => {
+      if (this.worker) {
+        try {
+          await this.rawCall('close');
+        } catch {
+          /* ignore */
+        }
+        this.worker.terminate();
+        this.worker = null;
       }
-      this.worker.terminate();
-      this.worker = null;
-    }
-    await this.connect(bucketId);
+      await this.openInternal(bucketId);
+    });
   }
 
   async close(): Promise<void> {