@spooky-sync/core 0.0.1-canary.117 → 0.0.1-canary.119

package/dist/index.js

@@ -1222,7 +1222,7 @@ function renderRelationFetchSurql(req) {
 		vars: { __keys: req.keys },
 		n: 0
 	};
-	let sql = `SELECT ${req.select && req.select.length > 0 ? ["id", ...req.select].join(", ") : "*"} FROM ${req.table} WHERE ${req.matchField} IN $__keys`;
+	let sql = `SELECT ${req.select && req.select.length > 0 ? ["id", ...req.select].join(", ") : "*"} FROM ${req.table} WHERE ${req.matchField} IN $__keys.map(|$__k| type::record(<string> $__k))`;
 	if (req.where && req.where.length > 0) sql += ` AND ${renderWhereSurql(req.where, ctx)}`;
 	if (req.orderBy && req.orderBy.length > 0) sql += renderOrderBy(req.orderBy);
 	return {
@@ -1563,7 +1563,7 @@ function pureWriteOpResult(op) {
 }
 /**
 * Local cache backend on official SQLite-WASM in a dedicated Worker (see
-* `sqlite-worker.ts`), with OPFS SAHPool persistence. Storage model: one table
+* `sqlite-worker.js`), with OPFS SAHPool persistence. Storage model: one table
 * per schema table, `id TEXT PRIMARY KEY, data TEXT` where `data` is the row as
 * JSON. Filtering/ordering use `json_extract`. Relations are decomposed by the
 * shared {@link resolveRelations} — identical to the SurrealDB backend.
@@ -1616,7 +1616,7 @@ var SqliteCacheEngine = class {
 		return () => {};
 	}
 	spawnWorker() {
-		const worker = new Worker(new URL("./sqlite-worker.ts", import.meta.url), { type: "module" });
+		const worker = new Worker(new URL("./sqlite-worker.js", import.meta.url), { type: "module" });
 		worker.onmessage = (ev) => {
 			const { id, ok, error, ...rest } = ev.data ?? {};
 			const p = this.pending.get(id);
@@ -5100,8 +5100,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.117";
-const WASM_VERSION = "0.0.1-canary.117";
+const CORE_VERSION = "0.0.1-canary.119";
+const WASM_VERSION = "0.0.1-canary.119";
 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.117",
+  "version": "0.0.1-canary.119",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,8 +59,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.117",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.117",
+    "@spooky-sync/query-builder": "0.0.1-canary.119",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.119",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/sync/sync.subquery.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+import { buildSubqueryListRefSelect } from './utils';
+import { encodeRecordId } from '../../utils/index';
+
+// Guards the CLIENT half of `.related()` (author/comments) delivery: given
+// subquery-child edges on the server (`_00_list_ref…` rows with
+// `parent IS NOT NONE`), `syncSubqueryChildren` MUST pull the child bodies
+// through the sync engine so a later re-materialization attaches them to the
+// parent. If this stops forwarding the child ids, related fields come back
+// empty (threads render with an "Anonymous" author, comments vanish) even
+// though the server wrote the edges correctly.
+
+function makeSync() {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn() };
+  const queryId = new RecordId('_00_query', 'h1');
+  const queryState: any = { config: { id: queryId, subqueryRemoteArray: [] } };
+  const dataModule: any = { getQueryByHash: vi.fn().mockReturnValue(queryState) };
+
+  const sync = new Sp00kySync(
+    {} as any, remote, {} as any, dataModule, {} as any, logger,
+  );
+
+  // syncEngine is constructed internally; replace it with a spy.
+  const syncRecords = vi.fn().mockResolvedValue(undefined);
+  (sync as any).syncEngine = { syncRecords };
+  // Pin the resolved per-user list_ref table (auth routing is out of scope here).
+  (sync as any).listRefTable = () => '_00_list_ref_user_x';
+
+  const run = (hash: string) => (sync as any).syncSubqueryChildren(hash) as Promise<void>;
+  return { remote, syncRecords, queryState, queryId, run };
+}
+
+describe('syncSubqueryChildren — related-child delivery', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('reads the subquery edges (parent IS NOT NONE) scoped to the query id', async () => {
+    const { remote, run, queryId } = makeSync();
+    remote.query.mockResolvedValue([[]]);
+
+    await run('h1');
+
+    expect(remote.query).toHaveBeenCalledWith(
+      buildSubqueryListRefSelect('_00_list_ref_user_x'),
+      { in: queryId }
+    );
+  });
+
+  it('forwards each subquery child id to the sync engine so its body is cached', async () => {
+    const { remote, syncRecords, run } = makeSync();
+    // Server has one author child edge for this query.
+    remote.query.mockResolvedValue([[
+      { out: new RecordId('user', 'u'), version: 1 },
+    ]]);
+
+    await run('h1');
+
+    expect(syncRecords).toHaveBeenCalledTimes(1);
+    const arg = syncRecords.mock.calls[0][0];
+    expect(arg.added).toHaveLength(1);
+    expect(encodeRecordId(arg.added[0].id)).toBe('user:u');
+    expect(arg.added[0].version).toBe(1);
+    expect(arg.removed).toEqual([]); // shared child bodies are never deleted here
+  });
+
+  it('is idempotent: unchanged edges do not refetch bodies', async () => {
+    const { remote, syncRecords, run, queryState } = makeSync();
+    queryState.config.subqueryRemoteArray = [['user:u', 1]];
+    remote.query.mockResolvedValue([[
+      { out: new RecordId('user', 'u'), version: 1 },
+    ]]);
+
+    await run('h1');
+
+    expect(syncRecords).not.toHaveBeenCalled();
+  });
+});

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

@@ -51,7 +51,7 @@ describe('renderRelationFetchSurql', () => {
       where: [{ field: 'hidden', op: '=', value: false }],
       orderBy: [['rank', 'asc']],
     });
-    expect(sql).toBe('SELECT * FROM comment WHERE post IN $__keys AND hidden = $__p0 ORDER BY rank asc;');
+    expect(sql).toBe('SELECT * FROM comment WHERE post IN $__keys.map(|$__k| type::record(<string> $__k)) AND hidden = $__p0 ORDER BY rank asc;');
     expect(vars).toEqual({ __keys: ['post:1', 'post:2'], __p0: false });
   });
 });

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

@@ -77,7 +77,12 @@ export function renderRelationFetchSurql(req: RelationFetch): RenderedQuery {
   const ctx: RenderCtx = { vars: { __keys: req.keys }, n: 0 };
   const projection =
     req.select && req.select.length > 0 ? ['id', ...req.select].join(', ') : '*';
-  let sql = `SELECT ${projection} FROM ${req.table} WHERE ${req.matchField} IN $__keys`;
+  // The correlation keys arrive as record-id STRINGS (`"user:abc"`), but the
+  // matched column (`id`, or a `record<…>` foreign key) is a RecordId. In
+  // SurrealDB `id IN ["user:abc"]` never matches (string ≠ record), so every
+  // `.related()` field would resolve empty. Coerce each key to a record id with
+  // `type::record(<string> …)` (idempotent if a key is already a RecordId).
+  let sql = `SELECT ${projection} FROM ${req.table} WHERE ${req.matchField} IN $__keys.map(|$__k| type::record(<string> $__k))`;
   if (req.where && req.where.length > 0) {
     sql += ` AND ${renderWhereSurql(req.where, ctx)}`;
   }

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

@@ -106,7 +106,13 @@ export class SqliteCacheEngine implements LocalStore {
   // ---- worker plumbing -----------------------------------------------------
 
   private spawnWorker(): Worker {
-    // The worker is a separate module entry; the bundler rewrites this URL.
+    // Source references the `.ts` so the monorepo's src-bundling consumers
+    // (e.g. the example app, which aliases `@spooky-sync/core` to `src`) resolve
+    // it — Vite handles `.ts` workers. For the published package, the tsdown
+    // build rewrites this to `./sqlite-worker.js` (the top-level emitted entry;
+    // see tsdown.config.ts), which the flat `dist/index.js` resolves. The worker
+    // (+ `@sqlite.org/sqlite-wasm`) still loads lazily — only when `localEngine:
+    // 'sqlite'` is used.
     const worker = new Worker(new URL('./sqlite-worker.ts', import.meta.url), { type: 'module' });
     worker.onmessage = (ev: MessageEvent) => {
       const { id, ok, error, ...rest } = ev.data ?? {};

package/tsdown.config.ts

@@ -53,6 +53,19 @@ const versionDefinePlugin = {
   },
 };
 
+// The SQLite worker URL is written as `./sqlite-worker.ts` in source so Vite's
+// src-bundling consumers (the example app aliases core to `src`) resolve it.
+// In the published build the worker is emitted at `dist/sqlite-worker.js`, so
+// rewrite the reference to `.js` here — otherwise the flat `dist/index.js`
+// carries a dangling `.ts` URL that a consumer's bundler can't resolve.
+const sqliteWorkerUrlPlugin = {
+  name: 'sp00ky-sqlite-worker-url',
+  transform(code: string) {
+    if (!code.includes('sqlite-worker.ts')) return null;
+    return code.split('sqlite-worker.ts').join('sqlite-worker.js');
+  },
+};
+
 export default defineConfig({
   // `sqlite-worker` is emitted at `dist/sqlite-worker.js` (top level, NOT under
   // services/database) so the `new URL('./sqlite-worker.js', import.meta.url)`
@@ -68,5 +81,5 @@ export default defineConfig({
   dts: true,
   clean: true,
   hash: false,
-  plugins: [versionDefinePlugin],
+  plugins: [versionDefinePlugin, sqliteWorkerUrlPlugin],
 });