@pylonsync/react 0.5.0 → 0.5.3

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.0",
+  "version": "0.5.3",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",
@@ -14,8 +14,8 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@pylonsync/sdk": "0.5.0",
-    "@pylonsync/sync": "0.5.0"
+    "@pylonsync/sdk": "0.5.3",
+    "@pylonsync/sync": "0.5.3"
   },
   "peerDependencies": {
     "react": ">=19.0.0"

package/src/index.ts

@@ -236,7 +236,58 @@ export function configureClient(config: AgentDBClientConfig): void {
     maybeWarnDowngrade(config.baseUrl);
   }
   if (config.appName) {
+    const prev = _appName;
     _appName = config.appName;
+    // An app moving off the default (unprefixed `pylon_token`) keyspace onto
+    // its own `pylon:<app>:token` namespace keeps its session: copy the legacy
+    // keys up once. COPY, never delete — a framework rollback still finds the
+    // old keys.
+    if (config.appName !== "default" && prev === "default") {
+      adoptLegacyKeys();
+    }
+  }
+}
+
+/** Session slots whose legacy (default-keyspace) value is adopted into the
+ *  app namespace on first `configureClient({ appName })`. */
+const MIGRATED_SLOTS = ["token", "userId"] as const;
+
+/**
+ * A `pylon:<other>:token` key already on this origin means another Pylon app
+ * has run here — so the unprefixed `pylon_token` cannot be assumed to be OURS.
+ * The legacy keyspace records no owner, and on a shared origin (every app on
+ * localhost:4321 in dev) that stranger's token is usually invalid for us.
+ * Adopt only when this looks like the origin's sole app; otherwise leave the
+ * slot empty and let a real sign-in fill it. Web-only — RN's per-app async
+ * adapters are already isolated, so the shared-origin hazard doesn't exist.
+ */
+function anotherAppNamespaced(): boolean {
+  if (typeof localStorage === "undefined") return false;
+  const mine = storageKey("token");
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (k && k.startsWith("pylon:") && k.endsWith(":token") && k !== mine) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function adoptLegacyKeys(): void {
+  try {
+    if (anotherAppNamespaced()) return; // legacy token is likely foreign — skip
+    for (const slot of MIGRATED_SLOTS) {
+      const nsKey = storageKey(slot); // pylon:<app>:<slot>
+      const legacyKey = `pylon_${slot}`;
+      if (nsKey === legacyKey) continue;
+      const existing = _storage.get(nsKey);
+      if (existing != null && existing !== "") continue; // already namespaced
+      const legacy = _storage.get(legacyKey);
+      if (legacy != null && legacy !== "") _storage.set(nsKey, legacy);
+    }
+  } catch {
+    // Storage can be absent (SSR/node) or throw (Safari private mode) —
+    // never let a migration attempt break client configuration.
   }
 }
 

package/src/storageMigration.test.ts

@@ -0,0 +1,76 @@
+// A fresh app defaulted `_appName` to "default", so `storageKey("token")`
+// returned the unprefixed `pylon_token`. Two apps on one origin (every app on
+// localhost:4321 in dev) then shared one token keyspace and clobbered each
+// other's sessions. When an app adopts a namespace, `configureClient` copies a
+// legacy default-keyspace session up so a single-app upgrade doesn't log anyone
+// out — but ONLY when the legacy key is plausibly ours (no other app has
+// namespaced here). These pin adopt / no-clobber / don't-import-a-stranger.
+//
+// `_appName` is a module global that only transitions off "default" once per
+// process, so `beforeEach` resets it (configureClient({ appName: "default" }))
+// and clears the origin's localStorage that the shared-origin guard reads.
+
+import { beforeEach, expect, test } from "bun:test";
+
+import { configureClient, setReactStorage, storageKey } from "./index";
+import type { Storage as PylonStorage } from "@pylonsync/sync";
+
+function memStorage(): PylonStorage & { map: Map<string, string> } {
+  const map = new Map<string, string>();
+  return {
+    map,
+    get: (k: string) => map.get(k) ?? null,
+    set: (k: string, v: string) => void map.set(k, v),
+    remove: (k: string) => void map.delete(k),
+  };
+}
+
+beforeEach(() => {
+  configureClient({ appName: "default" }); // reset the module-global _appName
+  if (typeof localStorage !== "undefined") localStorage.clear();
+});
+
+test("adopts a legacy pylon_token into the app namespace, non-destructively", () => {
+  const store = memStorage();
+  setReactStorage(store);
+  store.set("pylon_token", "tok_legacy");
+  store.set("pylon_userId", "user_1");
+
+  configureClient({ appName: "revtrail" });
+
+  // Session preserved under the new namespaced keys…
+  expect(store.get("pylon:revtrail:token")).toBe("tok_legacy");
+  expect(store.get("pylon:revtrail:userId")).toBe("user_1");
+  // …and COPIED, not moved — a framework rollback still finds the old key.
+  expect(store.get("pylon_token")).toBe("tok_legacy");
+  // storageKey now resolves to the namespace.
+  expect(storageKey("token")).toBe("pylon:revtrail:token");
+});
+
+test("does not clobber a token already in the app namespace", () => {
+  const store = memStorage();
+  setReactStorage(store);
+  store.set("pylon_token", "tok_legacy");
+  store.set("pylon:revtrail:token", "tok_current");
+
+  configureClient({ appName: "revtrail" });
+
+  expect(store.get("pylon:revtrail:token")).toBe("tok_current");
+});
+
+test("does not adopt a foreign pylon_token when another app is namespaced here", () => {
+  // Another Pylon app has already run on this origin (shared-origin repro from
+  // a 0.5.2 field report). The ownerless legacy key can't be assumed ours.
+  localStorage.setItem("pylon:otherapp:token", "tok_other_app");
+
+  const store = memStorage();
+  setReactStorage(store);
+  store.set("pylon_token", "tok_FOREIGN_from_another_app");
+
+  configureClient({ appName: "mastagents" });
+
+  // The stranger's token is NOT copied into our namespace…
+  expect(store.get("pylon:mastagents:token")).toBeNull();
+  // …and the legacy key is untouched (we never delete it either).
+  expect(store.get("pylon_token")).toBe("tok_FOREIGN_from_another_app");
+});