@spooky-sync/core 0.0.1-canary.227 → 0.0.1-canary.229

package/dist/index.d.ts

@@ -2587,6 +2587,28 @@ declare class Sp00kyClient<S extends SchemaStructure> {
    * outbox - and the connection supervisor keeps retrying underneath.
    */
   private initRemote;
+  /**
+   * Write the signed-in user's own row, as the SERVER just returned it, into
+   * the local store.
+   *
+   * `AuthService.check()` (boot verification, sign-in, an app-driven refresh)
+   * runs `SELECT * FROM ONLY $auth.id` and keeps the answer on
+   * `auth.currentUser`; nothing consumed it beyond the id. Meanwhile the app's
+   * own `user` query paints local-first from whatever body the store holds,
+   * and that body is only refreshed when the server's row version reaches
+   * this client through membership (`_00_list_ref`). While the SSP is down or
+   * bootstrapping that never happens, so a device that registered before the
+   * account was verified kept rendering a row without `email_verified` and
+   * the app parked the user on "Verify your email" over a server that said
+   * "already verified". The authoritative row was already in hand.
+   *
+   * MERGE semantics (`CacheModule.saveBatch`) keep local-only fields, and
+   * re-using the memoized version keeps the sync dedup honest: this is a
+   * field refresh, not a version claim. `notifyTableQueries` re-materializes
+   * the `user` queries so the gate flips without waiting for a stream update.
+   * Best-effort: a failure here leaves things exactly as they were.
+   */
+  private persistVerifiedUser;
   private bucketSwitchChain;
   private pendingBucketTarget;
   /**

package/dist/index.js

@@ -7764,8 +7764,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.227";
-const WASM_VERSION = "0.0.1-canary.227";
+const CORE_VERSION = "0.0.1-canary.229";
+const WASM_VERSION = "0.0.1-canary.229";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12780,7 +12780,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.227",
+				coreVersion: "0.0.1-canary.229",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,
@@ -12971,6 +12971,7 @@ var Sp00kyClient = class {
 						Category: "sp00ky-client::Sp00kyClient::authChange"
 					}, "sync.setCurrentUserId failed");
 				}
+				await this.persistVerifiedUser();
 			});
 			await this.sync.init();
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Sync initialized");
@@ -13027,6 +13028,51 @@ var Sp00kyClient = class {
 			}, "Auth verification failed; keeping the restored session");
 		}
 	}
+	/**
+	* Write the signed-in user's own row, as the SERVER just returned it, into
+	* the local store.
+	*
+	* `AuthService.check()` (boot verification, sign-in, an app-driven refresh)
+	* runs `SELECT * FROM ONLY $auth.id` and keeps the answer on
+	* `auth.currentUser`; nothing consumed it beyond the id. Meanwhile the app's
+	* own `user` query paints local-first from whatever body the store holds,
+	* and that body is only refreshed when the server's row version reaches
+	* this client through membership (`_00_list_ref`). While the SSP is down or
+	* bootstrapping that never happens, so a device that registered before the
+	* account was verified kept rendering a row without `email_verified` and
+	* the app parked the user on "Verify your email" over a server that said
+	* "already verified". The authoritative row was already in hand.
+	*
+	* MERGE semantics (`CacheModule.saveBatch`) keep local-only fields, and
+	* re-using the memoized version keeps the sync dedup honest: this is a
+	* field refresh, not a version claim. `notifyTableQueries` re-materializes
+	* the `user` queries so the gate flips without waiting for a stream update.
+	* Best-effort: a failure here leaves things exactly as they were.
+	*/
+	async persistVerifiedUser() {
+		const row = this.auth.currentUser;
+		if (!row || !(row.id instanceof RecordId) || Object.keys(row).length <= 1) return;
+		const rid = row.id;
+		const table = rid.table.toString();
+		const tableSchema = this.config.schema.tables.find((t) => t.name === table);
+		if (!tableSchema) return;
+		try {
+			const encoded = encodeRecordId(rid);
+			const version = this.cache.lookup(encoded) || 1;
+			await this.cache.saveBatch([{
+				table,
+				op: "UPDATE",
+				record: cleanRecord(tableSchema.columns, row),
+				version
+			}]);
+			await this.dataModule.notifyTableQueries(table);
+		} catch (e) {
+			this.logger.warn({
+				err: e,
+				Category: "sp00ky-client::Sp00kyClient::persistVerifiedUser"
+			}, "Could not persist the verified user row locally");
+		}
+	}
 	bucketSwitchChain = Promise.resolve();
 	pendingBucketTarget = null;
 	/**

package/package.json

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

package/src/sp00ky.auth-order.test.ts

@@ -63,6 +63,26 @@ describe('Sp00kyClient.auth.subscribe ordering invariant', () => {
     }
   });
 
+  it('persists the server-verified user row only after the bucket switch', () => {
+    // `persistVerifiedUser` writes `auth.currentUser` (the row `check()` got
+    // from `SELECT * FROM ONLY $auth.id`) into the local store so the app's
+    // `user` query stops rendering a stale, pre-verification body. It must run
+    // AFTER `ensureLocalBucket`, or the row lands in the previous user's
+    // bucket on a sign-in that switches accounts.
+    const match = source.match(
+      /this\.auth\.subscribe\(\s*async\s*\(\s*userId\s*[^)]*\)\s*=>\s*\{([\s\S]*?)\n {6}\}\s*\)/
+    );
+    expect(match).not.toBeNull();
+    const stripped = match![1]
+      .split('\n')
+      .map((line) => line.replace(/\/\/.*$/, ''))
+      .join('\n');
+    const bucketIdx = stripped.indexOf('this.ensureLocalBucket(userId)');
+    const persistIdx = stripped.indexOf('this.persistVerifiedUser()');
+    expect(persistIdx, 'persistVerifiedUser() must be called from the auth subscriber').toBeGreaterThanOrEqual(0);
+    expect(persistIdx).toBeGreaterThan(bucketIdx);
+  });
+
   it('writes the boot-bucket hint synchronously and switches buckets before sync.setCurrentUserId', () => {
     const match = source.match(
       /this\.auth\.subscribe\(\s*async\s*\(\s*userId\s*[^)]*\)\s*=>\s*\{([\s\S]*?)\n {6}\}\s*\)/

package/src/sp00ky.ts

@@ -53,6 +53,8 @@ import type { AppReleaseOptions } from './modules/app-release/index';
 import { LocalStoragePersistenceClient } from './services/persistence/localstorage';
 import { ANON_USER_ID, bucketIdForUser } from './modules/ref-tables';
 import { parseQueryParams, encodeRecordId, parseDuration } from './utils/index';
+import { cleanRecord } from './utils/parser';
+import { RecordId } from 'surrealdb';
 import { SurrealDBPersistenceClient } from './services/persistence/surrealdb';
 import { ResilientPersistenceClient } from './services/persistence/resilient';
 import { detectSharedTabsSupport } from './services/tabs/support';
@@ -976,6 +978,8 @@ export class Sp00kyClient<S extends SchemaStructure> {
             'sync.setCurrentUserId failed'
           );
         }
+        // After the bucket switch, so the row lands in THIS user's store.
+        await this.persistVerifiedUser();
       });
 
       await this.sync.init();
@@ -1083,6 +1087,54 @@ export class Sp00kyClient<S extends SchemaStructure> {
     }
   }
 
+  /**
+   * Write the signed-in user's own row, as the SERVER just returned it, into
+   * the local store.
+   *
+   * `AuthService.check()` (boot verification, sign-in, an app-driven refresh)
+   * runs `SELECT * FROM ONLY $auth.id` and keeps the answer on
+   * `auth.currentUser`; nothing consumed it beyond the id. Meanwhile the app's
+   * own `user` query paints local-first from whatever body the store holds,
+   * and that body is only refreshed when the server's row version reaches
+   * this client through membership (`_00_list_ref`). While the SSP is down or
+   * bootstrapping that never happens, so a device that registered before the
+   * account was verified kept rendering a row without `email_verified` and
+   * the app parked the user on "Verify your email" over a server that said
+   * "already verified". The authoritative row was already in hand.
+   *
+   * MERGE semantics (`CacheModule.saveBatch`) keep local-only fields, and
+   * re-using the memoized version keeps the sync dedup honest: this is a
+   * field refresh, not a version claim. `notifyTableQueries` re-materializes
+   * the `user` queries so the gate flips without waiting for a stream update.
+   * Best-effort: a failure here leaves things exactly as they were.
+   */
+  private async persistVerifiedUser(): Promise<void> {
+    const row = this.auth.currentUser as Record<string, unknown> | null;
+    if (!row || !(row.id instanceof RecordId) || Object.keys(row).length <= 1) return;
+    const rid = row.id as RecordId;
+    const table = rid.table.toString();
+    const tableSchema = this.config.schema.tables.find((t) => t.name === table);
+    if (!tableSchema) return;
+    try {
+      const encoded = encodeRecordId(rid);
+      const version = this.cache.lookup(encoded) || 1;
+      await this.cache.saveBatch([
+        {
+          table,
+          op: 'UPDATE',
+          record: cleanRecord(tableSchema.columns, row) as RecordWithId,
+          version,
+        },
+      ]);
+      await this.dataModule.notifyTableQueries(table);
+    } catch (e) {
+      this.logger.warn(
+        { err: e, Category: 'sp00ky-client::Sp00kyClient::persistVerifiedUser' },
+        'Could not persist the verified user row locally'
+      );
+    }
+  }
+
   // Serializes bucket switches from rapid auth flips; `pendingBucketTarget`
   // makes intermediate targets collapse (A→anon→B never opens the anon bucket).
   private bucketSwitchChain: Promise<void> = Promise.resolve();