jazz-tools 0.10.7 → 0.10.12

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-TSEO4KAO.js";
+} from "./chunk-RL7HVQ5Q.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-RL7HVQ5Q.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.12",
   "dependencies": {
     "@scure/bip39": "^1.3.0",
-    "cojson": "0.10.7"
+    "cojson": "0.10.8"
   },
   "devDependencies": {
     "tsup": "8.3.5",

package/src/coValues/deepLoading.ts

@@ -29,11 +29,33 @@ export function fulfillsDepth(depth: any, value: CoValue): boolean {
         const map = value as unknown as {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           [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

@@ -157,7 +157,7 @@ export class CoValueBase implements CoValue {
 
 export function loadCoValueWithoutMe<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
-  id: ID<V>,
+  id: ID<CoValue>,
   asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
   depth?: Depth & DepthsIn<V>,
 ) {
@@ -175,7 +175,7 @@ export function loadCoValueWithoutMe<V extends CoValue, Depth>(
 
 export function loadCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
-  id: ID<V>,
+  id: ID<CoValue>,
   as: Account | AnonymousJazzAgent,
   depth: Depth & DepthsIn<V>,
 ): Promise<DeeplyLoaded<V, Depth> | undefined> {
@@ -216,7 +216,7 @@ export async function ensureCoValueLoaded<V extends CoValue, Depth>(
 
 export function subscribeToCoValueWithoutMe<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
-  id: ID<V>,
+  id: ID<CoValue>,
   asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
   depthOrListener:
     | (Depth & DepthsIn<V>)
@@ -251,7 +251,7 @@ export function subscribeToCoValueWithoutMe<V extends CoValue, Depth>(
 
 export function subscribeToCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
-  id: ID<V>,
+  id: ID<CoValue>,
   as: Account | AnonymousJazzAgent,
   depth: Depth & DepthsIn<V>,
   listener: (value: DeeplyLoaded<V, Depth>, unsubscribe: () => void) => void,
@@ -263,7 +263,7 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
   let unsubscribed = false;
   let unsubscribe: (() => void) | undefined;
 
-  function subscribe(value: V | undefined) {
+  function subscribe(value: CoValue | undefined) {
     if (!value) {
       onUnavailable && onUnavailable();
       return;
@@ -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?.();
       });
   }
 
@@ -312,7 +313,7 @@ export function createCoValueObservable<V extends CoValue, Depth>(options?: {
 
   function subscribe(
     cls: CoValueClass<V>,
-    id: ID<V>,
+    id: ID<CoValue>,
     as: Account | AnonymousJazzAgent,
     depth: Depth & DepthsIn<V>,
     listener: () => void,

package/src/tests/ContextManager.test.ts

@@ -26,7 +26,6 @@ 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<

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,130 @@ 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);
+});
+
+test("should not throw when calling ensureLoaded a record with a deleted ref", 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 root = JazzySnapStore.create(
+    {
+      profile: JazzProfile.create({ firstName: "John" }, me),
+    },
+    me,
+  );
+
+  let value: any;
+  let unsub = root.subscribe([{}], (v) => {
+    value = v;
+  });
+
+  await waitFor(() => expect(value.profile).toBeDefined());
+
+  delete root.profile;
+
+  await waitFor(() => expect(value.profile).toBeUndefined());
+
+  unsub();
+
+  value = undefined;
+  unsub = root.subscribe([{}], (v) => {
+    value = v;
+  });
+
+  await waitFor(() => expect(value).toBeDefined());
+
+  expect(value.profile).toBeUndefined();
+
+  unsub();
+});

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