jazz-tools 0.10.4 → 0.10.6

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-XRX3CCYY.js";
+} from "./chunk-DPW23T6J.js";
 
 // src/index.ts
 import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals } from "cojson";

package/dist/testing.js

@@ -5,7 +5,7 @@ import {
   createAnonymousJazzContext,
   createJazzContext,
   randomSessionProvider
-} from "./chunk-XRX3CCYY.js";
+} from "./chunk-DPW23T6J.js";
 
 // src/testing.ts
 import { LocalNode } from "cojson";

package/package.json

@@ -17,10 +17,10 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "dependencies": {
     "@scure/bip39": "^1.3.0",
-    "cojson": "0.10.4"
+    "cojson": "0.10.6"
   },
   "devDependencies": {
     "tsup": "8.3.5",

package/src/auth/AuthSecretStorage.ts

@@ -28,16 +28,50 @@ export class AuthSecretStorage {
     if (!(await kvStore.get(STORAGE_KEY))) {
       const demoAuthSecret = await kvStore.get("demo-auth-logged-in-secret");
       if (demoAuthSecret) {
-        await kvStore.set(STORAGE_KEY, demoAuthSecret);
+        const parsed = JSON.parse(demoAuthSecret);
+        await kvStore.set(
+          STORAGE_KEY,
+          JSON.stringify({
+            accountID: parsed.accountID,
+            accountSecret: parsed.accountSecret,
+            provider: "demo",
+          }),
+        );
         await kvStore.delete("demo-auth-logged-in-secret");
       }
 
       const clerkAuthSecret = await kvStore.get("jazz-clerk-auth");
       if (clerkAuthSecret) {
-        await kvStore.set(STORAGE_KEY, clerkAuthSecret);
+        const parsed = JSON.parse(clerkAuthSecret);
+        await kvStore.set(
+          STORAGE_KEY,
+          JSON.stringify({
+            accountID: parsed.accountID,
+            accountSecret: parsed.secret,
+            provider: "clerk",
+          }),
+        );
         await kvStore.delete("jazz-clerk-auth");
       }
     }
+
+    const value = await kvStore.get(STORAGE_KEY);
+
+    if (value) {
+      const parsed = JSON.parse(value);
+
+      if ("secret" in parsed) {
+        await kvStore.set(
+          STORAGE_KEY,
+          JSON.stringify({
+            accountID: parsed.accountID,
+            secretSeed: parsed.secretSeed,
+            accountSecret: parsed.secret,
+            provider: parsed.provider,
+          }),
+        );
+      }
+    }
   }
 
   async get(): Promise<AuthCredentials | null> {

package/src/implementation/createContext.ts

@@ -110,14 +110,19 @@ export async function createJazzContextFromExistingCredentials<
     sessionID: sessionID,
     peersToLoadFrom: peersToLoadFrom,
     crypto: crypto,
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new CurrentAccountSchema({
+        fromRaw: rawAccount,
+      }) as Acc;
+      activeAccountContext.set(account);
+
+      await account.applyMigration(creationProps);
+    },
   });
 
   const account = CurrentAccountSchema.fromNode(node);
   activeAccountContext.set(account);
 
-  // Running the migration outside of withLoadedAccount for better error management
-  await account.applyMigration();
-
   return {
     node,
     account,

package/src/tests/AuthSecretStorage.test.ts

@@ -28,20 +28,52 @@ describe("AuthSecretStorage", () => {
 
       await authSecretStorage.migrate();
 
-      expect(await kvStore.get("jazz-logged-in-secret")).toBe(demoSecret);
+      expect(await kvStore.get("jazz-logged-in-secret")).toBe(
+        JSON.stringify({
+          accountID: "demo123",
+          accountSecret: "secret123",
+          provider: "demo",
+        }),
+      );
       expect(await kvStore.get("demo-auth-logged-in-secret")).toBeNull();
     });
 
     it("should migrate clerk auth secret", async () => {
       const clerkSecret = JSON.stringify({
         accountID: "clerk123",
-        accountSecret: "secret123",
+        secret: "secret123",
       });
       await kvStore.set("jazz-clerk-auth", clerkSecret);
 
       await authSecretStorage.migrate();
 
-      expect(await kvStore.get("jazz-logged-in-secret")).toBe(clerkSecret);
+      expect(await kvStore.get("jazz-logged-in-secret")).toBe(
+        JSON.stringify({
+          accountID: "clerk123",
+          accountSecret: "secret123",
+          provider: "clerk",
+        }),
+      );
+      expect(await kvStore.get("jazz-clerk-auth")).toBeNull();
+    });
+
+    it("should migrate auth wrong secret key to accountSecret", async () => {
+      const clerkSecret = JSON.stringify({
+        accountID: "clerk123",
+        secret: "secret123",
+        provider: "clerk",
+      });
+      await kvStore.set("jazz-logged-in-secret", clerkSecret);
+
+      await authSecretStorage.migrate();
+
+      expect(await kvStore.get("jazz-logged-in-secret")).toBe(
+        JSON.stringify({
+          accountID: "clerk123",
+          accountSecret: "secret123",
+          provider: "clerk",
+        }),
+      );
       expect(await kvStore.get("jazz-clerk-auth")).toBeNull();
     });
   });

package/src/tests/ContextManager.test.ts

@@ -196,6 +196,87 @@ describe("ContextManager", () => {
     expect(onAnonymousAccountDiscarded).not.toHaveBeenCalled();
   });
 
+  test("the migration should be applied correctly on existing accounts ", async () => {
+    class AccountRoot extends CoMap {
+      value = co.string;
+    }
+
+    let lastRootId: string | undefined;
+
+    class CustomAccount extends Account {
+      root = co.ref(AccountRoot);
+
+      migrate() {
+        this.root = AccountRoot.create({
+          value: "Hello",
+        });
+        lastRootId = this.root.id;
+      }
+    }
+    const customManager = new TestJazzContextManager<CustomAccount>();
+
+    // Create initial anonymous context
+    await customManager.createContext({
+      AccountSchema: CustomAccount,
+    });
+
+    const account = (
+      customManager.getCurrentValue() as JazzAuthContext<CustomAccount>
+    ).me;
+
+    await customManager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+
+    expect(me.root.id).toBe(lastRootId);
+  });
+
+  test("the migration should be applied correctly on existing accounts (2)", async () => {
+    class AccountRoot extends CoMap {
+      value = co.number;
+    }
+
+    class CustomAccount extends Account {
+      root = co.ref(AccountRoot);
+
+      async migrate(this: CustomAccount) {
+        if (this.root === undefined) {
+          this.root = AccountRoot.create({
+            value: 1,
+          });
+        } else {
+          const { root } = await this.ensureLoaded({ root: {} });
+
+          root.value = 2;
+        }
+      }
+    }
+    const customManager = new TestJazzContextManager<CustomAccount>();
+
+    // Create initial anonymous context
+    await customManager.createContext({
+      AccountSchema: CustomAccount,
+    });
+
+    const account = (
+      customManager.getCurrentValue() as JazzAuthContext<CustomAccount>
+    ).me;
+
+    await customManager.authenticate({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+
+    expect(me.root.value).toBe(2);
+  });
+
   test("onAnonymousAccountDiscarded should work on transfering data between accounts", async () => {
     class AccountRoot extends CoMap {
       value = co.string;