@spooky-sync/core 0.0.1-canary.157 → 0.0.1-canary.158

package/dist/index.js

@@ -4010,7 +4010,7 @@ var UpQueue = class {
 	async enqueueFromDatabase(mutationId) {
 		if (this.queue.some((e) => encodeUpEventId(e) === mutationId)) return;
 		try {
-			const [records] = await this.local.query(`SELECT * FROM $mutation_id`, { mutation_id: parseRecordIdString(mutationId) });
+			const [records] = await this.local.query(`SELECT * FROM $mutation_ids`, { mutation_ids: [parseRecordIdString(mutationId)] });
 			const event = Array.isArray(records) && records[0] ? rowToUpEvent(records[0], this.logger) : null;
 			if (event) this.addToQueue(event);
 		} catch (error) {
@@ -5694,8 +5694,8 @@ async function walkOpfs(maxEntries = 2e3, maxDepth = 8) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.157";
-const WASM_VERSION = "0.0.1-canary.157";
+const CORE_VERSION = "0.0.1-canary.158";
+const WASM_VERSION = "0.0.1-canary.158";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -8939,7 +8939,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.157",
+				coreVersion: "0.0.1-canary.158",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.157",
+  "version": "0.0.1-canary.158",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.157",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.157",
+    "@spooky-sync/query-builder": "0.0.1-canary.158",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.158",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/sync/queue/queue-up.forwarded.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { UpQueue } from './queue-up';
+import { translateSurql } from '../../../services/database/surql-translate';
 
 function makeLogger(): any {
   const noop = () => {};
@@ -21,7 +22,8 @@ const ROW = {
 describe('UpQueue.enqueueFromDatabase', () => {
   function makeQueue(rows: Record<string, unknown[]>) {
     const query = vi.fn(async (_sql: string, vars?: Record<string, unknown>) => {
-      const id = String(vars?.mutation_id ?? '');
+      const ids = (vars?.mutation_ids as unknown[]) ?? [];
+      const id = String(ids[0] ?? '');
       return [rows[id] ?? []];
     });
     const local: any = { query };
@@ -48,4 +50,26 @@ describe('UpQueue.enqueueFromDatabase', () => {
     await queue.enqueueFromDatabase(ROW.id);
     expect(queue.size).toBe(0);
   });
+
+  // The mock above replaces `local.query` wholesale, so on its own it proves
+  // nothing about the SQLite engine actually being able to RUN the statement.
+  // That gap shipped a bug: the emitted `SELECT * FROM $mutation_id` passed a
+  // single RecordId where the engine's `selectByIds` lowering expects an array,
+  // so it threw, the surrounding catch swallowed it at `error` level, and every
+  // follower mutation was silently never pushed. Drive the real translator.
+  it('emits a statement the SQLite engine can actually translate', async () => {
+    const { queue, query } = makeQueue({ [ROW.id]: [ROW] });
+    await queue.enqueueFromDatabase(ROW.id);
+
+    const [sql, vars] = query.mock.calls[0] as [string, Record<string, unknown>];
+    const translated = translateSurql(sql, vars);
+    const op: any = translated.ops[0];
+
+    expect(op.kind).toBe('selectByIds');
+    // The engine does `ids.length` then `ids.map(...)`: a non-array silently
+    // skips the empty-guard and then throws.
+    expect(Array.isArray(op.ids)).toBe(true);
+    expect(op.ids).toHaveLength(1);
+    expect(() => (op.ids as unknown[]).map((x) => x)).not.toThrow();
+  });
 });

package/src/modules/sync/queue/queue-up.ts

@@ -1,11 +1,7 @@
 import type { RecordId } from 'surrealdb';
 import type { LocalStore } from '../../../services/database/index';
-import type {
-  SyncQueueEventSystem} from '../events/index';
-import {
-  createSyncQueueEventSystem,
-  SyncQueueEventTypes,
-} from '../events/index';
+import type { SyncQueueEventSystem } from '../events/index';
+import { createSyncQueueEventSystem, SyncQueueEventTypes } from '../events/index';
 import {
   parseRecordIdString,
   extractTablePart,
@@ -50,7 +46,10 @@ export class UpQueue {
   private queue: UpEvent[] = [];
   private _events: SyncQueueEventSystem;
   private logger: Logger;
-  private debouncedMutations: Map<string, { timer: any; firstBeforeRecord?: Record<string, unknown> }>;
+  private debouncedMutations: Map<
+    string,
+    { timer: any; firstBeforeRecord?: Record<string, unknown> }
+  >;
 
   get events(): SyncQueueEventSystem {
     return this._events;
@@ -199,10 +198,19 @@ export class UpQueue {
   async enqueueFromDatabase(mutationId: string): Promise<void> {
     if (this.queue.some((e) => encodeUpEventId(e) === mutationId)) return;
     try {
-      const [records] = await this.local.query<any>(`SELECT * FROM $mutation_id`, {
-        mutation_id: parseRecordIdString(mutationId),
+      // ARRAY param, matching SyncEngine's `SELECT * FROM $idsToFetch`. A bare
+      // `FROM $singleRecordId` looks fine against SurrealDB but the SQLite
+      // engine lowers any `FROM $param` to `selectByIds` and calls `.map` on
+      // the param (surql-translate.ts, SqliteCacheEngine.selectByIds), so a
+      // single RecordId threw. The throw landed in the catch below, which logs
+      // at `error` — invisible to an app running `logLevel: 'fatal'` — so every
+      // forwarded mutation was silently dropped: the follower's optimistic
+      // write stuck locally, was never pushed, and the next down-sync reverted it.
+      const [records] = await this.local.query<any>(`SELECT * FROM $mutation_ids`, {
+        mutation_ids: [parseRecordIdString(mutationId)],
       });
-      const event = Array.isArray(records) && records[0] ? rowToUpEvent(records[0], this.logger) : null;
+      const event =
+        Array.isArray(records) && records[0] ? rowToUpEvent(records[0], this.logger) : null;
       if (event) this.addToQueue(event);
     } catch (error) {
       this.logger.error(
@@ -266,7 +274,11 @@ function rowToUpEvent(r: any, logger: Logger): UpEvent | null {
       };
     default:
       logger.warn(
-        { mutationType: r.mutationType, record: r, Category: 'sp00ky-client::UpQueue::rowToUpEvent' },
+        {
+          mutationType: r.mutationType,
+          record: r,
+          Category: 'sp00ky-client::UpQueue::rowToUpEvent',
+        },
         'Unknown mutation type'
       );
       return null;