jazz-tools 0.11.8 → 0.12.1

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, vi } from "vitest";
+import { assert, describe, expect, expectTypeOf, test, vi } from "vitest";
 import {
   Account,
   CoFeed,
@@ -15,6 +15,7 @@ import {
   isControlledAccount,
 } from "../index.js";
 import { randomSessionProvider } from "../internal.js";
+import { createJazzTestAccount, linkAccounts } from "../testing.js";
 import { waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
@@ -63,89 +64,104 @@ describe("Deep loading with depth arg", async () => {
       crypto: Crypto,
     });
 
-  test("loading a deeply nested object will wait until all required refs are loaded", async () => {
-    const ownership = { owner: me };
-    const map = TestMap.create(
-      {
-        list: TestList.create(
-          [
-            InnerMap.create(
-              {
-                stream: TestStream.create(
-                  [InnermostMap.create({ value: "hello" }, ownership)],
-                  ownership,
-                ),
-              },
-              ownership,
-            ),
-          ],
-          ownership,
-        ),
-      },
-      ownership,
-    );
+  const ownership = { owner: me };
+  const map = TestMap.create(
+    {
+      list: TestList.create(
+        [
+          InnerMap.create(
+            {
+              stream: TestStream.create(
+                [InnermostMap.create({ value: "hello" }, ownership)],
+                ownership,
+              ),
+            },
+            ownership,
+          ),
+        ],
+        ownership,
+      ),
+    },
+    ownership,
+  );
+
+  test("load without resolve", async () => {
+    const map1 = await TestMap.load(map.id, { loadAs: meOnSecondPeer });
+    expectTypeOf(map1).toEqualTypeOf<TestMap | null>();
+
+    assert(map1, "map1 is null");
 
-    const map1 = await TestMap.load(map.id, meOnSecondPeer, {});
-    expectTypeOf(map1).toEqualTypeOf<TestMap | undefined>();
-    if (map1 === undefined) {
-      throw new Error("map1 is undefined");
-    }
     expect(map1.list).toBe(null);
+  });
 
-    const map2 = await TestMap.load(map.id, meOnSecondPeer, { list: [] });
+  test("load with resolve { list: true }", async () => {
+    const map2 = await TestMap.load(map.id, {
+      loadAs: meOnSecondPeer,
+      resolve: { list: true },
+    });
     expectTypeOf(map2).toEqualTypeOf<
       | (TestMap & {
           list: TestList;
         })
-      | undefined
+      | null
     >();
-    if (map2 === undefined) {
-      throw new Error("map2 is undefined");
-    }
-    expect(map2.list).not.toBe(null);
+    assert(map2, "map2 is null");
+    expect(map2.list).toBeTruthy();
     expect(map2.list[0]).toBe(null);
+  });
 
-    const map3 = await TestMap.load(map.id, meOnSecondPeer, { list: [{}] });
+  test("load with resolve { list: { $each: true } }", async () => {
+    const map3 = await TestMap.load(map.id, {
+      loadAs: meOnSecondPeer,
+      resolve: { list: { $each: true } },
+    });
     expectTypeOf(map3).toEqualTypeOf<
       | (TestMap & {
           list: TestList & InnerMap[];
         })
-      | undefined
+      | null
     >();
-    if (map3 === undefined) {
-      throw new Error("map3 is undefined");
-    }
-    expect(map3.list[0]).not.toBe(null);
+    assert(map3, "map3 is null");
+    expect(map3.list[0]).toBeTruthy();
     expect(map3.list[0]?.stream).toBe(null);
+  });
 
-    const map3a = await TestMap.load(map.id, meOnSecondPeer, {
-      optionalRef: {},
+  test("load with resolve { optionalRef: true }", async () => {
+    const map3a = await TestMap.load(map.id, {
+      loadAs: meOnSecondPeer,
+      resolve: { optionalRef: true } as const,
     });
     expectTypeOf(map3a).toEqualTypeOf<
       | (TestMap & {
           optionalRef: InnermostMap | undefined;
         })
-      | undefined
+      | null
     >();
+    assert(map3a, "map3a is null");
+    expect(map3a).toBeTruthy();
+  });
 
-    const map4 = await TestMap.load(map.id, meOnSecondPeer, {
-      list: [{ stream: [] }],
+  test("load with resolve { list: { $each: { stream: true } } }", async () => {
+    const map4 = await TestMap.load(map.id, {
+      loadAs: meOnSecondPeer,
+      resolve: { list: { $each: { stream: true } } },
     });
     expectTypeOf(map4).toEqualTypeOf<
       | (TestMap & {
           list: TestList & (InnerMap & { stream: TestStream })[];
         })
-      | undefined
+      | null
     >();
-    if (map4 === undefined) {
-      throw new Error("map4 is undefined");
-    }
-    expect(map4.list[0]?.stream).not.toBe(null);
-    expect(map4.list[0]?.stream?.[me.id]).not.toBe(null);
+    assert(map4, "map4 is null");
+    expect(map4.list[0]?.stream).toBeTruthy();
+    expect(map4.list[0]?.stream?.[me.id]).toBeTruthy();
     expect(map4.list[0]?.stream?.byMe?.value).toBe(null);
+  });
 
-    const map5 = await TestMap.load(map.id, meOnSecondPeer, {
-      list: [{ stream: [{}] }],
+  test("load with resolve { list: { $each: { stream: { $each: true } } } }", async () => {
+    const map5 = await TestMap.load(map.id, {
+      loadAs: meOnSecondPeer,
+      resolve: { list: { $each: { stream: { $each: true } } } },
     });
     type ExpectedMap5 =
       | (TestMap & {
@@ -164,14 +180,12 @@ describe("Deep loading with depth arg", async () => {
               };
             })[];
         })
-      | undefined;
-
+      | null;
     expectTypeOf(map5).toEqualTypeOf<ExpectedMap5>();
-    if (map5 === undefined) {
-      throw new Error("map5 is undefined");
-    }
-    expect(map5.list[0]?.stream?.[me.id]?.value).not.toBe(null);
-    expect(map5.list[0]?.stream?.byMe?.value).not.toBe(null);
+    assert(map5, "map5 is null");
+
+    expect(map5.list[0]?.stream?.[me.id]?.value).toBeTruthy();
+    expect(map5.list[0]?.stream?.byMe?.value).toBeTruthy();
   });
 });
 
@@ -200,8 +214,10 @@ class CustomAccount extends Account {
     }
 
     const thisLoaded = await this.ensureLoaded({
-      profile: { stream: [] },
-      root: { list: [] },
+      resolve: {
+        profile: { stream: true },
+        root: { list: true },
+      },
     });
     expectTypeOf(thisLoaded).toEqualTypeOf<
       CustomAccount & {
@@ -223,8 +239,10 @@ test("Deep loading within account", async () => {
   });
 
   const meLoaded = await me.ensureLoaded({
-    profile: { stream: [] },
-    root: { list: [] },
+    resolve: {
+      profile: { stream: true },
+      root: { list: true },
+    },
   });
   expectTypeOf(meLoaded).toEqualTypeOf<
     CustomAccount & {
@@ -237,8 +255,8 @@ test("Deep loading within account", async () => {
     }
   >();
 
-  expect(meLoaded.profile.stream).not.toBe(null);
-  expect(meLoaded.root.list).not.toBe(null);
+  expect(meLoaded.profile.stream).toBeTruthy();
+  expect(meLoaded.root.list).toBeTruthy();
 });
 
 class RecordLike extends CoMap.Record(co.ref(TestMap)) {}
@@ -284,24 +302,242 @@ test("Deep loading a record-like coMap", async () => {
     { owner: me },
   );
 
-  const recordLoaded = await RecordLike.load(record.id, meOnSecondPeer, [
-    { list: [{}] },
-  ]);
+  const recordLoaded = await RecordLike.load(record.id, {
+    loadAs: meOnSecondPeer,
+    resolve: {
+      $each: { list: { $each: true } },
+    },
+  });
   expectTypeOf(recordLoaded).toEqualTypeOf<
     | (RecordLike & {
         [key: string]: TestMap & {
           list: TestList & InnerMap[];
         };
       })
-    | undefined
+    | null
   >();
-  if (recordLoaded === undefined) {
-    throw new Error("recordLoaded is undefined");
-  }
+  assert(recordLoaded, "recordLoaded is null");
   expect(recordLoaded.key1?.list).not.toBe(null);
-  expect(recordLoaded.key1?.list).not.toBe(undefined);
+  expect(recordLoaded.key1?.list).toBeTruthy();
   expect(recordLoaded.key2?.list).not.toBe(null);
-  expect(recordLoaded.key2?.list).not.toBe(undefined);
+  expect(recordLoaded.key2?.list).toBeTruthy();
+});
+
+test("The resolve type doesn't accept extra keys", async () => {
+  expect.assertions(1);
+
+  const me = await CustomAccount.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  try {
+    const meLoaded = await me.ensureLoaded({
+      resolve: {
+        // @ts-expect-error
+        profile: { stream: true, extraKey: true },
+        // @ts-expect-error
+        root: { list: true, extraKey: true },
+      },
+    });
+
+    await me.ensureLoaded({
+      resolve: {
+        // @ts-expect-error
+        root: { list: { $each: true, extraKey: true } },
+      },
+    });
+
+    await me.ensureLoaded({
+      resolve: {
+        root: { list: true },
+        // @ts-expect-error
+        extraKey: true,
+      },
+    });
+
+    expectTypeOf(meLoaded).toEqualTypeOf<
+      CustomAccount & {
+        profile: CustomProfile & {
+          stream: TestStream;
+          extraKey: never;
+        };
+        root: TestMap & {
+          list: TestList;
+          extraKey: never;
+        };
+      }
+    >();
+  } catch (e) {
+    expect(e).toBeInstanceOf(Error);
+  }
+});
+
+describe("Deep loading with unauthorized account", async () => {
+  const bob = await createJazzTestAccount({
+    creationProps: { name: "Bob" },
+  });
+
+  const alice = await createJazzTestAccount({
+    creationProps: { name: "Alice" },
+  });
+
+  linkAccounts(bob, alice);
+
+  await alice.waitForAllCoValuesSync();
+
+  const onlyBob = bob;
+  const group = Group.create(bob);
+
+  group.addMember(alice, "reader");
+
+  test("unaccessible root", async () => {
+    const map = TestMap.create({ list: TestList.create([], group) }, onlyBob);
+
+    const mapOnAlice = await TestMap.load(map.id, { loadAs: alice });
+
+    expect(mapOnAlice).toBe(null);
+  });
+
+  test("unaccessible list", async () => {
+    const map = TestMap.create({ list: TestList.create([], onlyBob) }, group);
+
+    const mapOnAlice = await TestMap.load(map.id, { loadAs: alice });
+    expect(mapOnAlice).toBeTruthy();
+
+    const mapWithListOnAlice = await TestMap.load(map.id, {
+      resolve: { list: true },
+      loadAs: alice,
+    });
+
+    expect(mapWithListOnAlice).toBe(null);
+  });
+
+  test("unaccessible list element", async () => {
+    const map = TestMap.create(
+      {
+        list: TestList.create(
+          [
+            InnerMap.create(
+              {
+                stream: TestStream.create([], group),
+              },
+              onlyBob,
+            ),
+          ],
+          group,
+        ),
+      },
+      group,
+    );
+
+    const mapOnAlice = await TestMap.load(map.id, {
+      resolve: { list: { $each: true } },
+      loadAs: alice,
+    });
+
+    expect(mapOnAlice).toBe(null);
+  });
+
+  test("unaccessible optional element", async () => {
+    const map = TestMap.create(
+      {
+        list: TestList.create([], group),
+        optionalRef: InnermostMap.create({ value: "hello" }, onlyBob),
+      },
+      group,
+    );
+
+    const mapOnAlice = await TestMap.load(map.id, {
+      loadAs: alice,
+      resolve: { optionalRef: true } as const,
+    });
+    expect(mapOnAlice).toBe(null);
+
+    expect(mapOnAlice?.optionalRef).toBe(undefined);
+    expect(mapOnAlice?.optionalRef?.value).toBe(undefined);
+  });
+
+  test("unaccessible optional element via autoload", async () => {
+    const map = TestMap.create(
+      {
+        list: TestList.create([], group),
+        optionalRef: InnermostMap.create({ value: "hello" }, onlyBob),
+      },
+      group,
+    );
+
+    const mapOnAlice = await TestMap.load(map.id, {
+      loadAs: alice,
+      resolve: { list: true } as const,
+    });
+
+    assert(mapOnAlice, "Alice isn't able to load the map");
+
+    const result = await new Promise((resolve) => {
+      const unsub = mapOnAlice.subscribe((value) => {
+        resolve(value.optionalRef);
+        unsub();
+      });
+    });
+
+    expect(result).toBe(null);
+  });
+
+  test("unaccessible stream", async () => {
+    const map = TestMap.create(
+      {
+        list: TestList.create(
+          [
+            InnerMap.create(
+              {
+                stream: TestStream.create([], onlyBob),
+              },
+              group,
+            ),
+          ],
+          group,
+        ),
+      },
+      group,
+    );
+
+    const mapOnAlice = await TestMap.load(map.id, {
+      resolve: { list: { $each: { stream: true } } },
+      loadAs: alice,
+    });
+
+    expect(mapOnAlice).toBe(null);
+  });
+
+  test("unaccessible stream element", async () => {
+    const map = TestMap.create(
+      {
+        list: TestList.create(
+          [
+            InnerMap.create(
+              {
+                stream: TestStream.create(
+                  [InnermostMap.create({ value: "hello" }, onlyBob)],
+                  group,
+                ),
+              },
+              group,
+            ),
+          ],
+          group,
+        ),
+      },
+      group,
+    );
+
+    const mapOnAlice = await TestMap.load(map.id, {
+      resolve: { list: { $each: { stream: { $each: true } } } },
+      loadAs: alice,
+    });
+
+    expect(mapOnAlice).toBe(null);
+  });
 });
 
 test("doesn't break on Map.Record key deletion when the key is referenced in the depth", async () => {
@@ -317,7 +553,10 @@ test("doesn't break on Map.Record key deletion when the key is referenced in the
   });
 
   const spy = vi.fn();
-  const unsub = snapStore.subscribe({ profile1: {}, profile2: {} }, spy);
+  const unsub = snapStore.subscribe(
+    { resolve: { profile1: true, profile2: true } },
+    spy,
+  );
 
   await waitFor(() => expect(spy).toHaveBeenCalled());
 
@@ -330,7 +569,9 @@ test("doesn't break on Map.Record key deletion when the key is referenced in the
 
   await expect(
     snapStore.ensureLoaded({
-      profile1: {},
+      resolve: {
+        profile1: true,
+      },
     }),
   ).rejects.toThrow("Failed to deeply load CoValue " + snapStore.id);
 });
@@ -357,7 +598,7 @@ test("throw when calling ensureLoaded on a ref that's required but missing", asy
 
   await expect(
     root.ensureLoaded({
-      profile: {},
+      resolve: { profile: true },
     }),
   ).rejects.toThrow("Failed to deeply load CoValue " + root.id);
 });
@@ -374,7 +615,7 @@ test("throw when calling ensureLoaded on a ref that is not defined in the schema
 
   await expect(
     root.ensureLoaded({
-      profile: {},
+      resolve: { profile: true },
     }),
   ).rejects.toThrow("Failed to deeply load CoValue " + root.id);
 });
@@ -399,7 +640,7 @@ test("should not throw when calling ensureLoaded a record with a deleted ref", a
   );
 
   let value: any;
-  let unsub = root.subscribe([{}], (v) => {
+  let unsub = root.subscribe({ resolve: { $each: true } }, (v) => {
     value = v;
   });
 
@@ -412,7 +653,7 @@ test("should not throw when calling ensureLoaded a record with a deleted ref", a
   unsub();
 
   value = undefined;
-  unsub = root.subscribe([{}], (v) => {
+  unsub = root.subscribe({ resolve: { $each: true } }, (v) => {
     value = v;
   });
 

package/src/tests/groupsAndAccounts.test.ts

@@ -106,18 +106,16 @@ describe("Group inheritance", () => {
 
     const mapInChild = TestMap.create({ title: "In Child" }, { owner: group });
 
-    const mapAsReader = await TestMap.load(mapInChild.id, reader, {});
+    const mapAsReader = await TestMap.load(mapInChild.id, { loadAs: reader });
     expect(mapAsReader?.title).toBe("In Child");
 
     await parentGroup.removeMember(reader);
 
     mapInChild.title = "In Child (updated)";
 
-    const mapAsReaderAfterUpdate = await TestMap.load(
-      mapInChild.id,
-      reader,
-      {},
-    );
+    const mapAsReaderAfterUpdate = await TestMap.load(mapInChild.id, {
+      loadAs: reader,
+    });
     expect(mapAsReaderAfterUpdate?.title).toBe("In Child");
   });
 
@@ -145,18 +143,18 @@ describe("Group inheritance", () => {
       { owner: group },
     );
 
-    const mapAsReader = await TestMap.load(mapInGrandChild.id, reader, {});
+    const mapAsReader = await TestMap.load(mapInGrandChild.id, {
+      loadAs: reader,
+    });
     expect(mapAsReader?.title).toBe("In Grand Child");
 
     await grandParentGroup.removeMember(reader);
 
     mapInGrandChild.title = "In Grand Child (updated)";
 
-    const mapAsReaderAfterUpdate = await TestMap.load(
-      mapInGrandChild.id,
-      reader,
-      {},
-    );
+    const mapAsReaderAfterUpdate = await TestMap.load(mapInGrandChild.id, {
+      loadAs: reader,
+    });
     expect(mapAsReaderAfterUpdate?.title).toBe("In Grand Child");
   });
 

package/src/tests/inbox.test.ts

@@ -146,7 +146,7 @@ describe("Inbox", () => {
     );
     const resultId = await inboxSender.sendMessage(message);
 
-    const result = await Message.load(resultId, receiver, {});
+    const result = await Message.load(resultId, { loadAs: receiver });
     expect(result?.text).toBe("Responded from the inbox");
 
     unsubscribe();

package/src/tests/schemaUnion.test.ts

@@ -89,23 +89,16 @@ describe("SchemaUnion", () => {
       { owner: me },
     );
 
-    const loadedButtonWidget = await loadCoValue(
-      WidgetUnion,
-      buttonWidget.id,
-      me,
-      {},
-    );
-    const loadedSliderWidget = await loadCoValue(
-      WidgetUnion,
-      sliderWidget.id,
-      me,
-      {},
-    );
+    const loadedButtonWidget = await loadCoValue(WidgetUnion, buttonWidget.id, {
+      loadAs: me,
+    });
+    const loadedSliderWidget = await loadCoValue(WidgetUnion, sliderWidget.id, {
+      loadAs: me,
+    });
     const loadedCheckboxWidget = await loadCoValue(
       WidgetUnion,
       checkboxWidget.id,
-      me,
-      {},
+      { loadAs: me },
     );
 
     expect(loadedButtonWidget).toBeInstanceOf(RedButtonWidget);
@@ -122,8 +115,7 @@ describe("SchemaUnion", () => {
     const unsubscribe = subscribeToCoValue(
       WidgetUnion,
       buttonWidget.id,
-      me,
-      {},
+      { loadAs: me, syncResolution: true },
       (value: BaseWidget) => {
         if (value instanceof BlueButtonWidget) {
           expect(value.label).toBe(currentValue);
@@ -131,8 +123,6 @@ describe("SchemaUnion", () => {
           throw new Error("Unexpected widget type");
         }
       },
-      () => {},
-      true,
     );
     currentValue = "Changed";
     buttonWidget.label = "Changed";