jazz-tools 0.10.6 → 0.10.8

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",
@@ -79,6 +79,11 @@ describe("AuthSecretStorage", () => {
   });
 
   describe("get", () => {
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage();
+    });
+
     it("should return null when no data exists", async () => {
       expect(await authSecretStorage.get()).toBeNull();
     });
@@ -132,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>,
@@ -165,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();
 
@@ -275,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>,
@@ -287,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);
+      });
+    });
+
+    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).toHaveBeenCalled();
+        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,
+    );
   }
 }
 

package/src/tests/coMap.test.ts

@@ -1,5 +1,5 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test, vi } from "vitest";
 import { Group, randomSessionProvider } from "../exports.js";
 import {
   Account,
@@ -10,7 +10,7 @@ import {
   createJazzContextFromExistingCredentials,
   isControlledAccount,
 } from "../index.js";
-import { setupTwoNodes } from "./utils.js";
+import { setupTwoNodes, waitFor } from "./utils.js";
 
 const connectedPeers = cojsonInternals.connectedPeers;
 

package/src/tests/deepLoading.test.ts

@@ -1,6 +1,6 @@
 import { cojsonInternals } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test, vi } from "vitest";
 import {
   Account,
   CoFeed,
@@ -14,6 +14,7 @@ import {
   isControlledAccount,
 } from "../index.js";
 import { randomSessionProvider } from "../internal.js";
+import { waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 const { connectedPeers } = cojsonInternals;
@@ -303,3 +304,86 @@ test("Deep loading a record-like coMap", async () => {
   expect(recordLoaded.key2?.list).not.toBe(null);
   expect(recordLoaded.key2?.list).not.toBe(undefined);
 });
+
+test("doesn't break on Map.Record key deletion when the key is referenced in the depth", async () => {
+  class JazzProfile extends CoMap {
+    firstName = co.string;
+  }
+
+  class JazzySnapStore extends CoMap.Record(co.ref(JazzProfile)) {}
+
+  const me = await Account.create({
+    creationProps: { name: "Tester McTesterson" },
+    crypto: Crypto,
+  });
+
+  const snapStore = JazzySnapStore.create(
+    {
+      profile1: JazzProfile.create({ firstName: "John" }, { owner: me }),
+      profile2: JazzProfile.create({ firstName: "John" }, { owner: me }),
+    },
+    { owner: me },
+  );
+
+  const spy = vi.fn();
+  const unsub = snapStore.subscribe({ profile1: {}, profile2: {} }, spy);
+
+  await waitFor(() => expect(spy).toHaveBeenCalled());
+
+  spy.mockClear();
+  delete snapStore.profile1;
+
+  expect(Object.keys(snapStore)).toEqual(["profile2"]);
+
+  unsub();
+
+  await expect(
+    snapStore.ensureLoaded({
+      profile1: {},
+    }),
+  ).rejects.toThrow("Failed to deeply load CoValue " + snapStore.id);
+});
+
+test("throw when calling ensureLoaded on a ref that's required but missing", async () => {
+  class JazzProfile extends CoMap {
+    firstName = co.string;
+  }
+
+  class JazzRoot extends CoMap {
+    profile = co.ref(JazzProfile);
+  }
+
+  const me = await Account.create({
+    creationProps: { name: "Tester McTesterson" },
+    crypto: Crypto,
+  });
+
+  const root = JazzRoot.create(
+    // @ts-expect-error missing required ref
+    {},
+    { owner: me },
+  );
+
+  await expect(
+    root.ensureLoaded({
+      profile: {},
+    }),
+  ).rejects.toThrow("Failed to deeply load CoValue " + root.id);
+});
+
+test("throw when calling ensureLoaded on a ref that is not defined in the schema", async () => {
+  class JazzRoot extends CoMap {}
+
+  const me = await Account.create({
+    creationProps: { name: "Tester McTesterson" },
+    crypto: Crypto,
+  });
+
+  const root = JazzRoot.create({}, { owner: me });
+
+  await expect(
+    root.ensureLoaded({
+      profile: {},
+    }),
+  ).rejects.toThrow("Failed to deeply load CoValue " + root.id);
+});

package/src/tests/subscribe.test.ts

@@ -150,6 +150,45 @@ describe("subscribeToCoValue", () => {
     );
   });
 
+  it("shouldn't fire updates after unsubscribing", async () => {
+    const { me, meOnSecondPeer } = await setupAccount();
+
+    const chatRoom = createChatRoom(me, "General");
+    const updateFn = vi.fn();
+
+    const { messages } = await chatRoom.ensureLoaded({ messages: [{}] });
+
+    messages.push(createMessage(me, "Hello"));
+
+    const unsubscribe = subscribeToCoValue(
+      ChatRoom,
+      chatRoom.id,
+      meOnSecondPeer,
+      {
+        messages: [{}],
+      },
+      updateFn,
+    );
+
+    await waitFor(() => {
+      expect(updateFn).toHaveBeenCalled();
+    });
+
+    unsubscribe();
+    chatRoom.name = "Lounge";
+    messages.push(createMessage(me, "Hello 2"));
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(updateFn).toHaveBeenCalledTimes(1);
+    expect(updateFn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: chatRoom.id,
+      }),
+      expect.any(Function),
+    );
+  });
+
   it("should fire updates when a ref entity is updates", async () => {
     const { me, meOnSecondPeer } = await setupAccount();
 

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> =