@spooky-sync/core 0.0.1-canary.317 → 0.0.1-canary.319

package/dist/index.js

@@ -2178,8 +2178,8 @@ function trimHistory(history, cap) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.317";
-const WASM_VERSION = "0.0.1-canary.317";
+const CORE_VERSION = "0.0.1-canary.319";
+const WASM_VERSION = "0.0.1-canary.319";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	version = CORE_VERSION;
@@ -11574,7 +11574,7 @@ var AuthService = class {
 	* callback is called immediately with current value and whenever validation status changes.
 	*/
 	subscribe(cb) {
-		cb(this.currentUser?.id || null);
+		cb(this.announcedUserId());
 		const id = this.events.subscribe(AuthEventTypes.AuthStateChanged, (event) => {
 			cb(event.payload);
 		});
@@ -11614,8 +11614,24 @@ var AuthService = class {
 			clearTimeout(timer);
 		}
 	}
+	/**
+	* The signed-in user as subscribers see it: the raw `table:id` string, the
+	* way the token's `ID` claim spells it. `currentUser.id` is that string while
+	* the session is restored from the token and the server's `RecordId` once
+	* `check()` has answered, and the two must announce as the same user: every
+	* subscriber that compares ids (feature flags, app release) took the switch
+	* for a new principal and reset, so flag-gated UI blinked off and back on a
+	* few seconds into every reload. A `RecordId`'s own `toString()` will not do
+	* either, as it escapes ids like `user:⟨5abc⟩` that the claim spells raw.
+	*/
+	announcedUserId() {
+		const id = this.currentUser?.id;
+		if (!id) return null;
+		if (typeof id === "string") return id;
+		return id instanceof RecordId$1 ? encodeRecordId(id) : String(id);
+	}
 	notifyListeners() {
-		const userId = this.currentUser?.id || null;
+		const userId = this.announcedUserId();
 		this.events.emit(AuthEventTypes.AuthStateChanged, userId);
 		const impersonation = this.impersonation;
 		if (!sameImpersonation(impersonation, this.announcedImpersonation)) {
@@ -14766,7 +14782,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.317",
+			coreVersion: "0.0.1-canary.319",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/dist/types.d.ts

@@ -842,6 +842,17 @@ declare class AuthService<S extends SchemaStructure> {
    */
   onBeforeSignOut(hook: SignOutHook): () => void;
   private runSignOutHooks;
+  /**
+   * The signed-in user as subscribers see it: the raw `table:id` string, the
+   * way the token's `ID` claim spells it. `currentUser.id` is that string while
+   * the session is restored from the token and the server's `RecordId` once
+   * `check()` has answered, and the two must announce as the same user: every
+   * subscriber that compares ids (feature flags, app release) took the switch
+   * for a new principal and reset, so flag-gated UI blinked off and back on a
+   * few seconds into every reload. A `RecordId`'s own `toString()` will not do
+   * either, as it escapes ids like `user:⟨5abc⟩` that the claim spells raw.
+   */
+  private announcedUserId;
   private notifyListeners;
   /**
    * The impersonation the current session is, or null. Derived from the

package/package.json

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

package/src/modules/auth/auth.local-first.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
+import { RecordId } from 'surrealdb';
 import { AuthService } from './index';
 
 // A SurrealDB record-access JWT carries the access method as `AC` and the
@@ -139,3 +140,30 @@ describe('auth token reaches the transport', () => {
     expect(remote.setAuthToken).toHaveBeenLastCalledWith(null);
   });
 });
+
+describe('the announced user id', () => {
+  // The cached token names the user as a raw string; once check() answers,
+  // currentUser holds the server's RecordId. Subscribers compare ids, so the
+  // two must announce identically or every reload reads as a sign-in switch.
+  it.each([['abc'], ['5onl3w8g9jhnymk3d10p']])(
+    'is the same raw string before and after the server check (user:%s)',
+    async (key) => {
+      const claim = `user:${key}`;
+      const { auth } = makeAuth({
+        token: jwt({ AC: 'account', ID: claim }),
+        query: vi.fn(async () => [{ id: new RecordId('user', key), email: 'x@y' }]),
+      });
+      const seen: (string | null)[] = [];
+      auth.subscribe((uid) => seen.push(uid));
+
+      await auth.restoreSessionFromToken();
+      await auth.check();
+
+      expect(auth.currentUser.id).toBeInstanceOf(RecordId);
+      // A RecordId's toString escapes a key that starts with a digit.
+      expect(seen.filter((v) => v !== null)).toEqual([claim, claim]);
+      expect(seen.every((v) => v === null || typeof v === 'string')).toBe(true);
+    }
+  );
+});
+

package/src/modules/auth/index.ts

@@ -11,6 +11,7 @@ import { AuthEventTypes, createAuthEventSystem } from './events/index';
 import type { PersistenceClient } from '../../types';
 import { classifySyncError } from '../../utils/error-classification';
 import { encodeRecordId } from '../../utils/index';
+import { RecordId } from 'surrealdb';
 import {
   decodeTokenClaims,
   impersonationFromToken,
@@ -152,7 +153,7 @@ export class AuthService<S extends SchemaStructure> {
    */
   subscribe(cb: (userId: string | null) => void): () => void {
     // Immediate callback
-    cb(this.currentUser?.id || null);
+    cb(this.announcedUserId());
 
     const id = this.events.subscribe(AuthEventTypes.AuthStateChanged, (event) => {
       cb(event.payload);
@@ -197,8 +198,25 @@ export class AuthService<S extends SchemaStructure> {
     }
   }
 
+  /**
+   * The signed-in user as subscribers see it: the raw `table:id` string, the
+   * way the token's `ID` claim spells it. `currentUser.id` is that string while
+   * the session is restored from the token and the server's `RecordId` once
+   * `check()` has answered, and the two must announce as the same user: every
+   * subscriber that compares ids (feature flags, app release) took the switch
+   * for a new principal and reset, so flag-gated UI blinked off and back on a
+   * few seconds into every reload. A `RecordId`'s own `toString()` will not do
+   * either, as it escapes ids like `user:⟨5abc⟩` that the claim spells raw.
+   */
+  private announcedUserId(): string | null {
+    const id = this.currentUser?.id;
+    if (!id) return null;
+    if (typeof id === 'string') return id;
+    return id instanceof RecordId ? encodeRecordId(id as RecordId<string>) : String(id);
+  }
+
   private notifyListeners() {
-    const userId = this.currentUser?.id || null;
+    const userId = this.announcedUserId();
     this.events.emit(AuthEventTypes.AuthStateChanged, userId);
     const impersonation = this.impersonation;
     if (!sameImpersonation(impersonation, this.announcedImpersonation)) {

package/src/modules/feature-flag/index.test.ts

@@ -1,5 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { RecordId } from 'surrealdb';
 import { FeatureFlagModule } from './index';
+import { AuthService } from '../auth/index';
 
 // vitest runs in the `node` environment here, so there is no localStorage.
 // The module guards every access with `globalThis.localStorage?.`, which keeps
@@ -249,3 +251,48 @@ describe('FeatureFlagModule local overrides', () => {
     expect(() => new FeatureFlagModule(makeDeps().deps)).not.toThrow();
   });
 });
+
+describe('FeatureFlagModule across a reload', () => {
+  // A reload restores the session from the cached token (the id as a string),
+  // then the server check lands the user row (the id as a RecordId) a few
+  // seconds later. Same user: an assigned flag must stay on throughout, not
+  // blink off while the module re-registers its query.
+  it('keeps flags through the server verification of the same user', async () => {
+    const b64 = Buffer.from(JSON.stringify({ AC: 'account', ID: 'user:5abc' })).toString('base64url');
+    const token = `h.${b64}.s`;
+    const store = new Map<string, unknown>([['sp00ky_auth_token', token]]);
+    const persistence = {
+      get: async (k: string) => store.get(k) ?? null,
+      set: async (k: string, v: unknown) => void store.set(k, v),
+      remove: async (k: string) => void store.delete(k),
+    } as any;
+    const remote = {
+      query: async () => [{ id: new RecordId('user', '5abc') }],
+      setAuthToken: () => undefined,
+      getClient: () => ({ authenticate: async () => undefined, invalidate: async () => undefined }),
+    } as any;
+    const silent: any = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    silent.child = () => silent;
+    const auth = new AuthService({} as any, remote, persistence, silent);
+
+    const env = makeDeps();
+    const flags = new FeatureFlagModule({ ...env.deps, auth } as any);
+    flags.init();
+    await auth.restoreSessionFromToken();
+    const clubs = flags.feature('clubs');
+    const seen: (string | undefined)[] = [];
+    clubs.subscribe((s) => seen.push(s.variant));
+    await tick();
+    env.push([{ key: 'clubs', variant: 'on' }]);
+    expect(clubs.variant()).toBe('on');
+    const registrations = env.calls.length;
+
+    await auth.check();
+    await tick();
+
+    expect(clubs.variant()).toBe('on');
+    expect(seen.slice(seen.indexOf('on'))).not.toContain(undefined);
+    expect(env.calls.length).toBe(registrations);
+  });
+});
+