jazz-tools 0.10.5 → 0.10.7

package/src/tests/AuthSecretStorage.test.ts

@@ -13,12 +13,12 @@ KvStoreContext.getInstance().initialize(kvStore);
 let authSecretStorage = new AuthSecretStorage();
 
 describe("AuthSecretStorage", () => {
-  beforeEach(() => {
-    kvStore.clearAll();
-    authSecretStorage = new AuthSecretStorage();
-  });
-
   describe("migrate", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
     it("should migrate demo auth secret", async () => {
       const demoSecret = JSON.stringify({
         accountID: "demo123",
@@ -28,25 +28,62 @@ 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();
     });
   });
 
   describe("get", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
     it("should return null when no data exists", async () => {
       expect(await authSecretStorage.get()).toBeNull();
     });
@@ -100,6 +137,11 @@ describe("AuthSecretStorage", () => {
   });
 
   describe("set", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
     it("should set credentials with secretSeed", async () => {
       const payload = {
         accountID: "test123" as ID<Account>,
@@ -133,61 +175,14 @@ describe("AuthSecretStorage", () => {
       const stored = JSON.parse((await kvStore.get("jazz-logged-in-secret"))!);
       expect(stored).toEqual(payload);
     });
-
-    it("should emit update event when setting credentials", async () => {
-      const handler = vi.fn();
-      authSecretStorage.onUpdate(handler);
-
-      await authSecretStorage.set({
-        accountID: "test123" as ID<Account>,
-        accountSecret:
-          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
-        provider: "passphrase",
-      });
-
-      expect(handler).toHaveBeenCalled();
-    });
   });
 
-  describe("isAuthenticated", () => {
-    it("should return false when no data exists", async () => {
-      expect(authSecretStorage.isAuthenticated).toBe(false);
-    });
-
-    it("should return false for anonymous credentials", async () => {
-      await authSecretStorage.set({
-        accountID: "test123" as ID<Account>,
-        accountSecret:
-          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
-        secretSeed: new Uint8Array([1, 2, 3]),
-        provider: "anonymous",
-      });
-      expect(authSecretStorage.isAuthenticated).toBe(false);
-    });
-
-    it("should return true for non-anonymous credentials", async () => {
-      await authSecretStorage.set({
-        accountID: "test123" as ID<Account>,
-        accountSecret:
-          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
-        secretSeed: new Uint8Array([1, 2, 3]),
-        provider: "demo",
-      });
-      expect(authSecretStorage.isAuthenticated).toBe(true);
-    });
-
-    it("should return true when the provider is missing", async () => {
-      await authSecretStorage.set({
-        accountID: "test123" as ID<Account>,
-        accountSecret:
-          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
-        secretSeed: new Uint8Array([1, 2, 3]),
-      } as any);
-      expect(authSecretStorage.isAuthenticated).toBe(true);
+  describe("onUpdate", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
     });
-  });
 
-  describe("onUpdate", () => {
     it("should add and remove event listener", () => {
       const handler = vi.fn();
 
@@ -243,6 +238,11 @@ describe("AuthSecretStorage", () => {
   });
 
   describe("clear", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
     it("should remove stored credentials", async () => {
       await authSecretStorage.set({
         accountID: "test123" as ID<Account>,
@@ -255,21 +255,179 @@ describe("AuthSecretStorage", () => {
 
       expect(await authSecretStorage.get()).toBeNull();
     });
+  });
 
-    it("should emit update event when clearing", async () => {
-      await authSecretStorage.set({
-        accountID: "test123" as ID<Account>,
-        accountSecret:
-          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
-        provider: "passphrase",
+  describe("notify=true", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+      authSecretStorage.notify = true;
+    });
+
+    describe("set", () => {
+      it("should emit update event when setting credentials", async () => {
+        const handler = vi.fn();
+        authSecretStorage.onUpdate(handler);
+
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          provider: "passphrase",
+        });
+
+        expect(handler).toHaveBeenCalled();
       });
+    });
 
-      const handler = vi.fn();
-      authSecretStorage.onUpdate(handler);
+    describe("isAuthenticated", () => {
+      it("should return false when no data exists", async () => {
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+      });
 
-      await authSecretStorage.clear();
+      it("should return false for anonymous credentials", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+          provider: "anonymous",
+        });
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+      });
+
+      it("should return true for non-anonymous credentials", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+          provider: "demo",
+        });
+        expect(authSecretStorage.isAuthenticated).toBe(true);
+      });
+
+      it("should return true when the provider is missing", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+        } as any);
+        expect(authSecretStorage.isAuthenticated).toBe(true);
+      });
+    });
 
-      expect(handler).toHaveBeenCalled();
+    describe("clear", () => {
+      it("should emit update event when clearing", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          provider: "passphrase",
+        });
+
+        const handler = vi.fn();
+        authSecretStorage.onUpdate(handler);
+
+        await authSecretStorage.clear();
+
+        expect(handler).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("notify=false", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
+    describe("set", () => {
+      it("should not emit update event when setting credentials", async () => {
+        const handler = vi.fn();
+        authSecretStorage.onUpdate(handler);
+
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          provider: "passphrase",
+        });
+
+        expect(handler).not.toHaveBeenCalled();
+      });
+    });
+
+    describe("isAuthenticated", () => {
+      it("should return false when no data exists", async () => {
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+      });
+
+      it("should return false for anonymous credentials", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+          provider: "anonymous",
+        });
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+      });
+
+      it("should return true for non-anonymous credentials", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+          provider: "demo",
+        });
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+        authSecretStorage.emitUpdate({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+          provider: "demo",
+        });
+        expect(authSecretStorage.isAuthenticated).toBe(true);
+      });
+
+      it("should return true when the provider is missing", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+        } as any);
+        expect(authSecretStorage.isAuthenticated).toBe(false);
+        authSecretStorage.emitUpdate({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          secretSeed: new Uint8Array([1, 2, 3]),
+        } as any);
+        expect(authSecretStorage.isAuthenticated).toBe(true);
+      });
+    });
+
+    describe("clear", () => {
+      it("should not emit update event when clearing", async () => {
+        await authSecretStorage.set({
+          accountID: "test123" as ID<Account>,
+          accountSecret:
+            "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+          provider: "passphrase",
+        });
+
+        const handler = vi.fn();
+        authSecretStorage.onUpdate(handler);
+
+        await authSecretStorage.clear();
+
+        expect(handler).not.toHaveBeenCalled();
+      });
     });
   });
 });

package/src/tests/ContextManager.test.ts

@@ -26,6 +26,7 @@ import {
   setupJazzTestSync,
 } from "../testing";
 
+// @ts-ignore Typescript in VSCode doesn't like top level await
 const Crypto = await WasmCrypto.create();
 
 class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
@@ -53,16 +54,20 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       AccountSchema: props.AccountSchema,
     });
 
-    this.updateContext(props, {
-      me: context.account,
-      node: context.node,
-      done: () => {
-        context.done();
+    await this.updateContext(
+      props,
+      {
+        me: context.account,
+        node: context.node,
+        done: () => {
+          context.done();
+        },
+        logOut: async () => {
+          await context.logOut();
+        },
       },
-      logOut: async () => {
-        await context.logOut();
-      },
-    });
+      authProps,
+    );
   }
 }
 
@@ -199,7 +204,6 @@ describe("ContextManager", () => {
   test("the migration should be applied correctly on existing accounts ", async () => {
     class AccountRoot extends CoMap {
       value = co.string;
-      transferredRoot = co.optional.ref(AccountRoot);
     }
 
     let lastRootId: string | undefined;
@@ -236,6 +240,48 @@ describe("ContextManager", () => {
     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;

package/src/types.ts

@@ -24,6 +24,7 @@ export type JazzAuthContext<Acc extends Account> = {
   authenticate: AuthenticateAccountFunction;
   logOut: () => Promise<void>;
   done: () => void;
+  isAuthenticated?: boolean;
 };
 
 export type JazzGuestContext = {
@@ -32,6 +33,7 @@ export type JazzGuestContext = {
   authenticate: AuthenticateAccountFunction;
   logOut: () => void;
   done: () => void;
+  isAuthenticated?: boolean;
 };
 
 export type JazzContextType<Acc extends Account> =