jazz-tools 0.10.7 → 0.10.8

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-TSEO4KAO.js";
+} from "./chunk-6OJCOJJ6.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-TSEO4KAO.js";
+} from "./chunk-6OJCOJJ6.js";
 
 // src/testing.ts
 import { LocalNode } from "cojson";

package/package.json

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

package/src/coValues/deepLoading.ts

@@ -31,9 +31,32 @@ export function fulfillsDepth(depth: any, value: CoValue): boolean {
           [key: string]: any;
           _refs: { [key: string]: Ref<CoValue> | undefined };
         };
-        if (!map._refs[key] && map._schema[key].optional) {
-          continue;
+
+        if (map._raw.get(key) === undefined) {
+          if (!map._schema?.[key]) {
+            if (map._schema?.[ItemsSym]) {
+              // CoMap.Record
+              if (map._schema[ItemsSym].optional) {
+                continue;
+              } else {
+                throw new Error(
+                  `The ref ${key} requested on ${map.constructor.name} is missing`,
+                );
+              }
+            } else {
+              throw new Error(
+                `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
+              );
+            }
+          } else if (map._schema[key].optional) {
+            continue;
+          } else {
+            throw new Error(
+              `The ref ${key} on ${map.constructor.name} is required but missing`,
+            );
+          }
         }
+
         if (!map[key]) {
           return false;
         }

package/src/coValues/interfaces.ts

@@ -295,6 +295,7 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
       .then((value) => subscribe(value))
       .catch((e) => {
         console.error("Failed to load / subscribe to CoValue", e);
+        onUnavailable?.();
       });
   }
 

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();