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

package/dist/sqlite-worker.js

@@ -1,5 +1,77 @@
+import { i as reviveRow, n as renderOrderSql, o as resolveRelations, r as renderWhereSql, s as stableKey, t as project } from "./sqlite-plan-sql.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 
+//#region src/services/database/sqlite-select.ts
+function ensureTable(db, table) {
+	if (db.knownTables.has(table)) return;
+	db.run(`CREATE TABLE IF NOT EXISTS "${table}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`);
+	db.knownTables.add(table);
+}
+function execRows(db, sql, bind) {
+	return db.exec(sql, bind).map((r) => reviveRow(r.data));
+}
+/** Mirrors the engine's `selectByIds`: fetch by primary id, preserving `ids`
+*  order unless an ORDER BY overrides it. */
+function selectByIds(db, table, ids, opts) {
+	if (ids.length === 0) return [];
+	ensureTable(db, table);
+	const keys = ids.map(stableKey);
+	let sql = `SELECT data FROM "${table}" WHERE id IN (${keys.map(() => "?").join(", ")})`;
+	if (opts?.orderBy && opts.orderBy.length > 0) sql += renderOrderSql(opts.orderBy);
+	let rows = execRows(db, sql, keys);
+	if (!opts?.orderBy || opts.orderBy.length === 0) {
+		const pos = new Map(keys.map((k, i) => [k, i]));
+		rows = rows.sort((a, b) => (pos.get(stableKey(a.id)) ?? 0) - (pos.get(stableKey(b.id)) ?? 0));
+	}
+	return opts?.select ? rows.map((r) => project(r, opts.select)) : rows;
+}
+/** Mirrors the engine's `fetchRelation` SQL exactly. */
+function fetchRelation(db, req) {
+	ensureTable(db, req.table);
+	const keys = req.keys.map(stableKey);
+	const placeholders = keys.map(() => "?").join(", ");
+	const bind = [...keys];
+	const lhs = req.matchField === "id" ? "id" : `json_extract(data, '$.${req.matchField}')`;
+	let sql = `SELECT data FROM "${req.table}" WHERE ${lhs} IN (${placeholders})`;
+	if (req.where && req.where.length > 0) sql += ` AND ${renderWhereSql(req.where, bind, {})}`;
+	if (req.orderBy && req.orderBy.length > 0) sql += renderOrderSql(req.orderBy);
+	const rows = execRows(db, sql, bind);
+	return req.select ? rows.map((r) => project(r, req.select)) : rows;
+}
+async function executeSelect(plan, params, db) {
+	const counter = { n: 0 };
+	const fetcher = { fetchRelation: (req) => {
+		counter.n++;
+		return Promise.resolve(fetchRelation(db, req));
+	} };
+	if (plan.ids) {
+		const rows = selectByIds(db, plan.table, plan.ids, {
+			select: plan.select,
+			orderBy: plan.orderBy
+		});
+		await resolveRelations(rows, plan.relations, fetcher);
+		return {
+			rows,
+			relationFetches: counter.n
+		};
+	}
+	ensureTable(db, plan.table);
+	const bind = [];
+	let sql = `SELECT data FROM "${plan.table}"`;
+	if (plan.where && plan.where.length > 0) sql += ` WHERE ${renderWhereSql(plan.where, bind, params)}`;
+	if (plan.orderBy && plan.orderBy.length > 0) sql += renderOrderSql(plan.orderBy);
+	if (plan.limit !== void 0) sql += ` LIMIT ${Number(plan.limit)}`;
+	if (plan.offset !== void 0) sql += ` OFFSET ${Number(plan.offset)}`;
+	const rows = execRows(db, sql, bind);
+	const projected = plan.select ? rows.map((r) => project(r, plan.select)) : rows;
+	await resolveRelations(projected, plan.relations, fetcher);
+	return {
+		rows: projected,
+		relationFetches: counter.n
+	};
+}
+
+//#endregion
 //#region src/services/database/sqlite-worker.ts
 /**
 * Dedicated Web Worker that owns the SQLite-WASM handle. All DB access is
@@ -11,11 +83,17 @@ import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 * to an in-memory DB when OPFS is unavailable.
 *
 * Message protocol (request/response keyed by `id`):
-*   { id, type: 'open',  payload: { dbName, useOpfs } }
-*   { id, type: 'exec',  payload: { sql, bind } }  -> { id, ok, rows }
-*   { id, type: 'run',   payload: { sql, bind } }  -> { id, ok }
-*   { id, type: 'batch', payload: [{ sql, bind }] } (atomic BEGIN/COMMIT)
+*   { id, type: 'open',   payload: { dbName, useOpfs } }
+*   { id, type: 'exec',   payload: { sql, bind } }  -> { id, ok, rows }
+*   { id, type: 'run',    payload: { sql, bind } }  -> { id, ok }
+*   { id, type: 'batch',  payload: [{ sql, bind }] } (atomic BEGIN/COMMIT)
+*   { id, type: 'select', payload: { plan, params } } -> { id, ok, rows, relationFetches }
 *   { id, type: 'close' }
+*
+* `select` executes a whole QueryPlan — table creation, base select, the full
+* `.related()` tree (shared `resolveRelations`), and JSON row parsing — in ONE
+* round-trip, returning structured-clone row objects. This is the first-load
+* hot path; the per-statement ops remain for the write/shim paths.
 */
 let db = null;
 async function open(dbName, useOpfs) {
@@ -63,14 +141,27 @@ function batch(stmts) {
 		throw e;
 	}
 }
+/** DB handle for `executeSelect` (see `sqlite-select.ts`, the unit-testable
+*  plan executor). `knownTables` is cleared on open/close — a bucket switch
+*  spawns a fresh worker anyway. */
+const selectDb = {
+	exec: (sql, bind) => exec(sql, bind),
+	run,
+	knownTables: /* @__PURE__ */ new Set()
+};
 self.onmessage = async (ev) => {
 	const { id, type, payload } = ev.data ?? {};
+	const t0 = performance.now();
 	try {
 		let result;
 		switch (type) {
 			case "open":
+				selectDb.knownTables.clear();
 				result = await open(payload.dbName, payload.useOpfs);
 				break;
+			case "select":
+				result = await executeSelect(payload.plan, payload.params ?? {}, selectDb);
+				break;
 			case "exec":
 				result = { rows: exec(payload.sql, payload.bind) };
 				break;
@@ -85,6 +176,7 @@ self.onmessage = async (ev) => {
 			case "close":
 				db?.close();
 				db = null;
+				selectDb.knownTables.clear();
 				result = {};
 				break;
 			default: throw new Error(`sqlite worker: unknown message ${type}`);
@@ -92,6 +184,7 @@ self.onmessage = async (ev) => {
 		self.postMessage({
 			id,
 			ok: true,
+			wt: performance.now() - t0,
 			...result
 		});
 	} catch (err) {

package/dist/types.d.ts

@@ -404,6 +404,13 @@ interface Sp00kyConfig<S extends SchemaStructure> {
     store?: StoreType;
     /** Authentication token. */
     token?: string;
+    /**
+     * SQLite engine only: execute `select` plans (base rows + relation tree +
+     * row parsing) inside the worker as ONE round-trip instead of one hop per
+     * table/relation level. Defaults to true; set false to force the legacy
+     * multi-hop path (escape hatch while the worker-side path beds in).
+     */
+    workerSelect?: boolean;
   };
   /** The schema definition. */
   schema: S;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.132",
+  "version": "0.0.1-canary.134",
   "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.134",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.134",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/services/database/plan-render.test.ts

@@ -73,6 +73,32 @@ describe('record-id coercion (authors/comments loading regression)', () => {
     expect(sql).toBe('SELECT * FROM thread WHERE title = $__p0 AND published = $__p1;');
   });
 
+  // Regression guard for the thread-detail "crossed results → 404" bug: a
+  // slave-mode node carries BOTH a baked `value` and a `paramRef` (= the field
+  // name). Materialization MUST bind `params[paramRef]` (the query's identity),
+  // NOT the baked value — otherwise a stale/other plan whose baked id ≠ the
+  // query's params would surface a different record's row. So rendering a plan
+  // baked to id-A with params for id-B must filter by B.
+  it('slave-mode node binds params over the baked value (records follow identity)', () => {
+    const planBakedToA: QueryPlan = {
+      table: 'thread',
+      where: [{ field: 'id', op: '=', value: 'thread:A', paramRef: 'id' }],
+    };
+    const { sql, vars } = renderBaseSelectSurql(planBakedToA, { id: 'thread:B' });
+    expect(sql).toBe('SELECT * FROM thread WHERE id = type::record(<string> $id);');
+    expect(vars).toEqual({ id: 'thread:B' }); // B wins — the baked A is ignored
+  });
+
+  it('slave-mode node falls back to the baked value when the param is absent', () => {
+    const plan: QueryPlan = {
+      table: 'thread',
+      where: [{ field: 'id', op: '=', value: 'thread:A', paramRef: 'id' }],
+    };
+    const { sql, vars } = renderBaseSelectSurql(plan, {}); // no params.id
+    expect(sql).toBe('SELECT * FROM thread WHERE id = type::record(<string> $__p0);');
+    expect(vars).toEqual({ __p0: 'thread:A' });
+  });
+
   it('coerces `id` inside an OR group too', () => {
     const plan: QueryPlan = {
       table: 'thread',

package/src/services/database/plan-render.ts

@@ -26,7 +26,15 @@ function bind(ctx: RenderCtx, value: unknown): string {
 }
 
 function renderComparisonSurql(c: WhereComparison, ctx: RenderCtx): string {
-  const rawRight = c.paramRef ? `$${c.paramRef}` : bind(ctx, c.value);
+  // Prefer the query's own param (`paramRef`) so a filter materializes from
+  // `params` (the query's identity), not a baked literal — this is what slaves
+  // a query's rows to its id. A pure `$`-ref node has no `value`, so it always
+  // uses the param. A slave-mode node also carries `value` as a fallback for
+  // when the param is absent (e.g. a non-column field stripped by parseParams).
+  const useParam =
+    c.paramRef !== undefined &&
+    (c.value === undefined || Object.prototype.hasOwnProperty.call(ctx.vars, c.paramRef));
+  const rawRight = useParam ? `$${c.paramRef}` : bind(ctx, c.value);
   // `id` is a RecordId, but correlation/filter values arrive as record-id
   // STRINGS (e.g. "thread:abc"). On SurrealDB `id = "thread:abc"` never matches
   // (string ≠ record), so a base select filtered by id (e.g. the ThreadDetail

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

@@ -1,10 +1,101 @@
 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 === 'select') {
+        if (!this.dbOpen) { ok = false; error = 'sqlite: DB not open'; }
+        else rest = { rows: [], relationFetches: 0 };
+      } 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