@spooky-sync/core 0.0.1-canary.190 → 0.0.1-canary.192

package/dist/index.js

@@ -6676,7 +6676,7 @@ var Sp00kySync = class Sp00kySync {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
 		if (!queryState) return;
 		if (this.dataModule.hasSubscribers(queryHash)) return;
-		await this.remote.query(`DELETE $id`, { id: queryState.config.id });
+		await this.remote.query("fn::query::unsubscribe($id)", { id: queryState.config.id });
 		if (this.dataModule.hasSubscribers(queryHash)) {
 			this.enqueueDownEvent({
 				type: "register",
@@ -7003,8 +7003,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.190";
-const WASM_VERSION = "0.0.1-canary.190";
+const CORE_VERSION = "0.0.1-canary.192";
+const WASM_VERSION = "0.0.1-canary.192";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -11435,7 +11435,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.190",
+				coreVersion: "0.0.1-canary.192",
 				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.190",
+  "version": "0.0.1-canary.192",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.190",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.190",
+    "@spooky-sync/query-builder": "0.0.1-canary.192",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.192",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

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

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+// Guards the teardown half of shared views. A `_00_query` row can be shared by
+// several sessions of the same user, so releasing it MUST go through
+// `fn::query::unsubscribe` — which drops only this session from `subscribers`
+// and deletes the row when it was the last one. A bare `DELETE $id` here would
+// destroy the view and every `_00_list_ref` edge hanging off it for every other
+// live tab, which reads to the user as a list that silently goes blank.
+//
+// This was previously unenforceable: `_00_query` granted no delete permission,
+// so the old `DELETE $id` affected zero rows and did nothing at all. Now that
+// the table grants delete, a regression here is destructive rather than inert.
+
+function makeSync(opts: { hasSubscribers?: boolean[] } = {}) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue([{ released: true, remaining: 0 }]) };
+  const queryId = new RecordId('_00_query', 'h1');
+  const queryState: any = { config: { id: queryId } };
+
+  // Successive hasSubscribers() answers: [before the release, after it].
+  const answers = opts.hasSubscribers ?? [false, false];
+  let call = 0;
+  const hasSubscribers = vi.fn(() => answers[Math.min(call++, answers.length - 1)]);
+
+  const finalizeDeregister = vi.fn();
+  const dataModule: any = {
+    getQueryByHash: vi.fn().mockReturnValue(queryState),
+    hasSubscribers,
+    finalizeDeregister,
+  };
+
+  const sync = new Sp00kySync(
+    {} as any, remote, {} as any, dataModule, {} as any, logger,
+  );
+  const enqueueDownEvent = vi.fn();
+  (sync as any).enqueueDownEvent = enqueueDownEvent;
+
+  const run = (hash: string) => (sync as any).cleanupQuery(hash) as Promise<void>;
+  return { remote, dataModule, queryId, finalizeDeregister, enqueueDownEvent, run };
+}
+
+describe('cleanupQuery — releasing a possibly-shared view', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('releases through fn::query::unsubscribe, never a bare DELETE', async () => {
+    const { remote, run, queryId } = makeSync();
+
+    await run('h1');
+
+    expect(remote.query).toHaveBeenCalledWith('fn::query::unsubscribe($id)', {
+      id: queryId,
+    });
+    // The regression that would blank other tabs' lists.
+    const sql = remote.query.mock.calls.map((c: any[]) => c[0]).join('\n');
+    expect(sql).not.toMatch(/\bDELETE\b/i);
+  });
+
+  it('frees local state once released', async () => {
+    const { finalizeDeregister, enqueueDownEvent, run } = makeSync();
+
+    await run('h1');
+
+    expect(finalizeDeregister).toHaveBeenCalledWith('h1');
+    expect(enqueueDownEvent).not.toHaveBeenCalled();
+  });
+
+  it('does not touch the remote row if a subscriber reappeared before the release', async () => {
+    const { remote, finalizeDeregister, run } = makeSync({
+      hasSubscribers: [true],
+    });
+
+    await run('h1');
+
+    expect(remote.query).not.toHaveBeenCalled();
+    expect(finalizeDeregister).not.toHaveBeenCalled();
+  });
+
+  it('re-registers if a subscriber reappeared during the release await', async () => {
+    // Someone scrolled back / re-subscribed while the round trip was in flight.
+    // Re-registering covers both outcomes: recreate the view if we were the
+    // last subscriber, or re-add ourselves to `subscribers` if it survived.
+    const { finalizeDeregister, enqueueDownEvent, run } = makeSync({
+      hasSubscribers: [false, true],
+    });
+
+    await run('h1');
+
+    expect(enqueueDownEvent).toHaveBeenCalledWith({
+      type: 'register',
+      payload: { hash: 'h1' },
+    });
+    expect(finalizeDeregister).not.toHaveBeenCalled();
+  });
+
+  it('is tolerant of an already torn-down query', async () => {
+    const { remote, dataModule, run } = makeSync();
+    dataModule.getQueryByHash.mockReturnValue(undefined);
+
+    await expect(run('gone')).resolves.toBeUndefined();
+    expect(remote.query).not.toHaveBeenCalled();
+  });
+});

package/src/modules/sync/sync.ts

@@ -1751,11 +1751,19 @@ export class Sp00kySync<S extends SchemaStructure> {
 
   // Eager teardown of a deregistered query's remote `_00_query` view (opt-in,
   // e.g. a viewport-windowed list cancelling an off-screen window). Query ids
-  // are a deterministic hash of (surql+params), so a DELETE racing a scroll-back
-  // re-register (same id) could nuke a freshly-recreated view — hence two
-  // guards: abort if a subscriber reappeared BEFORE the delete; re-register if
-  // one reappears DURING the delete's network await. Tolerant of a
-  // missing/already-gone query (no throw).
+  // are a deterministic hash of (surql+params), so a release racing a
+  // scroll-back re-register (same id) could nuke a freshly-recreated view —
+  // hence two guards: abort if a subscriber reappeared BEFORE the release;
+  // re-register if one reappears DURING the release's network await. Tolerant
+  // of a missing/already-gone query (no throw).
+  //
+  // Releases via `fn::query::unsubscribe` rather than deleting the row
+  // outright. A `_00_query` row can be shared by several sessions of the same
+  // user, so a bare `DELETE` would tear the view — and every `_00_list_ref`
+  // edge hanging off it — out from under other live tabs. The function drops
+  // only this session from `subscribers` and deletes the row when it was the
+  // last one. (The old `DELETE $id` was harmless in practice only because the
+  // table granted no delete permission and it silently affected zero rows.)
   private async cleanupQuery(queryHash: string) {
     const queryState = this.dataModule.getQueryByHash(queryHash);
     if (!queryState) return; // already torn down / never registered
@@ -1763,10 +1771,14 @@ export class Sp00kySync<S extends SchemaStructure> {
     // Re-subscribed before the queued cleanup ran → keep everything as-is.
     if (this.dataModule.hasSubscribers(queryHash)) return;
 
-    await this.remote.query(`DELETE $id`, { id: queryState.config.id });
+    await this.remote.query('fn::query::unsubscribe($id)', {
+      id: queryState.config.id,
+    });
 
-    // Re-subscribed while we awaited the DELETE → the remote view is now gone
-    // but a subscriber needs it; recreate it instead of leaving a zombie.
+    // Re-subscribed while we awaited the release → re-register. Covers both
+    // outcomes: if we were the last subscriber the remote view is gone and this
+    // recreates it, and if it survived for other sessions this re-adds us to
+    // `subscribers` so our heartbeats keep counting.
     if (this.dataModule.hasSubscribers(queryHash)) {
       this.enqueueDownEvent({ type: 'register', payload: { hash: queryHash } });
       return;