jazz-tools 0.13.30 → 0.13.33

package/src/tests/deepLoading.test-d.ts

@@ -0,0 +1,393 @@
+import { cojsonInternals } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { assert, describe, expect, expectTypeOf, test, vi } from "vitest";
+import {
+  Account,
+  CoFeed,
+  CoList,
+  CoMap,
+  Group,
+  ID,
+  Profile,
+  SessionID,
+  co,
+  createJazzContextFromExistingCredentials,
+  isControlledAccount,
+} from "../index.js";
+import { randomSessionProvider } from "../internal.js";
+import { createJazzTestAccount } from "../testing.js";
+
+const Crypto = await WasmCrypto.create();
+const { connectedPeers } = cojsonInternals;
+
+class TestMap extends CoMap {
+  list = co.ref(TestList);
+  optionalRef = co.ref(InnermostMap, { optional: true });
+}
+
+class TestList extends CoList.Of(co.ref(() => InnerMap)) {}
+
+class InnerMap extends CoMap {
+  stream = co.ref(TestStream);
+}
+
+class TestStream extends CoFeed.Of(co.ref(() => InnermostMap)) {}
+
+class InnermostMap extends CoMap {
+  value = co.string;
+}
+
+const me = await createJazzTestAccount({});
+const map = TestMap.create({
+  list: TestList.create([], { owner: me }),
+});
+
+describe("Deep loading with depth arg", async () => {
+  test("load without resolve", async () => {
+    const map1 = await TestMap.load(map.id);
+
+    function validateType(map: TestMap | null) {
+      map;
+    }
+
+    validateType(map1);
+  });
+
+  test("load with resolve { list: true }", async () => {
+    const map2 = await TestMap.load(map.id, {
+      resolve: { list: true },
+    });
+    expectTypeOf(map2).toEqualTypeOf<
+      | (TestMap & {
+          list: TestList;
+        })
+      | null
+    >();
+  });
+
+  test("load with resolve { list: { $each: true } }", async () => {
+    const map3 = await TestMap.load(map.id, {
+      resolve: { list: { $each: true } },
+    });
+    expectTypeOf(map3).toEqualTypeOf<
+      | (TestMap & {
+          list: TestList & InnerMap[];
+        })
+      | null
+    >();
+  });
+
+  test("load with resolve { optionalRef: true }", async () => {
+    const map3a = await TestMap.load(map.id, {
+      resolve: { optionalRef: true } as const,
+    });
+    expectTypeOf(map3a).toEqualTypeOf<
+      | (TestMap & {
+          optionalRef: InnermostMap | undefined;
+        })
+      | null
+    >();
+  });
+
+  test("load with resolve { list: { $each: { stream: true } } }", async () => {
+    const map4 = await TestMap.load(map.id, {
+      resolve: { list: { $each: { stream: true } } },
+    });
+    expectTypeOf(map4).toEqualTypeOf<
+      | (TestMap & {
+          list: TestList & (InnerMap & { stream: TestStream })[];
+        })
+      | null
+    >();
+  });
+
+  test("load with resolve { list: { $each: { stream: { $each: true } } } }", async () => {
+    const map5 = await TestMap.load(map.id, {
+      resolve: { list: { $each: { stream: { $each: true } } } },
+    });
+    type ExpectedMap5 =
+      | (TestMap & {
+          list: TestList &
+            (InnerMap & {
+              stream: TestStream & {
+                byMe?: { value: InnermostMap };
+                inCurrentSession?: { value: InnermostMap };
+                perSession: {
+                  [sessionID: SessionID]: {
+                    value: InnermostMap;
+                  };
+                };
+              } & {
+                [key: ID<Account>]: { value: InnermostMap };
+              };
+            })[];
+        })
+      | null;
+    expectTypeOf(map5).toEqualTypeOf<ExpectedMap5>();
+  });
+
+  test("should handle $onError on CoList items", async () => {
+    class List extends CoList.Of(co.ref(() => InnerMap)) {}
+
+    const result = await List.load("x" as ID<List>, {
+      resolve: { $each: { $onError: null } },
+    });
+    function validateType(map: ((InnerMap | null)[] & List) | null) {
+      map;
+    }
+
+    validateType(result);
+    expectTypeOf(result).toEqualTypeOf<((InnerMap | null)[] & List) | null>();
+  });
+
+  test("should handle $onError on a child CoList", async () => {
+    class InnerMap extends CoMap {
+      value = co.string;
+    }
+    class List extends CoList.Of(co.ref(InnerMap)) {}
+    class MyMap extends CoMap {
+      list = co.ref(List);
+    }
+
+    const result = await MyMap.load("x" as ID<MyMap>, {
+      resolve: { list: { $each: { $onError: null } } },
+    });
+
+    function validateType(map: (InnerMap | null)[] & List) {
+      map;
+    }
+
+    assert(result);
+
+    validateType(result.list);
+  });
+
+  test("should handle $onError on CoMap.Record", async () => {
+    class Record extends CoMap.Record(co.ref(() => InnerMap)) {}
+
+    const result = await Record.load("x" as ID<Record>, {
+      resolve: { $each: { $onError: null } },
+    });
+
+    type ExpectedResult =
+      | ({
+          [key: string]: InnerMap | null;
+        } & Record)
+      | null;
+
+    function validateType(map: ExpectedResult) {
+      map;
+    }
+
+    validateType(result);
+    expectTypeOf(result).toEqualTypeOf<ExpectedResult>();
+  });
+
+  test("should handle $onError on a child CoMap.Record", async () => {
+    class Record extends CoMap.Record(co.ref(() => InnerMap)) {}
+    class MyMap extends CoMap {
+      record = co.ref(Record);
+    }
+
+    const result = await MyMap.load("x" as ID<MyMap>, {
+      resolve: { record: { $each: { $onError: null } } },
+    });
+
+    type ExpectedResult = {
+      [key: string]: InnerMap | null;
+    } & Record &
+      co<Record | null>;
+
+    function validateType(map: ExpectedResult) {
+      map;
+    }
+
+    assert(result);
+
+    validateType(result.record);
+    expectTypeOf(result.record).toEqualTypeOf<ExpectedResult>();
+  });
+
+  test("should handle $onError on a ref", async () => {
+    class Person extends CoMap {
+      name = co.string;
+      dog = co.ref(Dog);
+    }
+
+    class Dog extends CoMap {
+      name = co.string;
+    }
+
+    const result = await Person.load("x" as ID<Person>, {
+      resolve: { dog: { $onError: null } },
+    });
+
+    type ExpectedResult =
+      | (Person & {
+          dog: Dog | null;
+        })
+      | null;
+
+    function validateType(map: ExpectedResult) {
+      map;
+    }
+
+    validateType(result);
+    expectTypeOf(result).toEqualTypeOf<ExpectedResult>();
+  });
+});
+
+class CustomProfile extends Profile {
+  stream = co.ref(TestStream);
+}
+
+class CustomAccount extends Account {
+  profile = co.ref(CustomProfile);
+  root = co.ref(TestMap);
+
+  async migrate(
+    this: CustomAccount,
+    creationProps?: { name: string } | undefined,
+  ) {
+    if (creationProps) {
+      const profileGroup = Group.create(this);
+      this.profile = CustomProfile.create(
+        {
+          name: creationProps.name,
+          stream: TestStream.create([], this),
+        },
+        profileGroup,
+      );
+      this.root = TestMap.create({ list: TestList.create([], this) }, this);
+    }
+
+    const thisLoaded = await this.ensureLoaded({
+      resolve: {
+        profile: { stream: true },
+        root: { list: true },
+      },
+    });
+    expectTypeOf(thisLoaded).toEqualTypeOf<
+      CustomAccount & {
+        profile: CustomProfile & {
+          stream: TestStream;
+        };
+        root: TestMap & {
+          list: TestList;
+        };
+      }
+    >();
+  }
+}
+
+test("Deep loading within account", async () => {
+  const me = await CustomAccount.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const meLoaded = await me.ensureLoaded({
+    resolve: {
+      profile: { stream: true },
+      root: { list: true },
+    },
+  });
+  expectTypeOf(meLoaded).toEqualTypeOf<
+    CustomAccount & {
+      profile: CustomProfile & {
+        stream: TestStream;
+      };
+      root: TestMap & {
+        list: TestList;
+      };
+    }
+  >();
+});
+
+class RecordLike extends CoMap.Record(co.ref(TestMap)) {}
+
+test("Deep loading a record-like coMap", async () => {
+  const me = await Account.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+    peer1role: "server",
+    peer2role: "client",
+  });
+
+  if (!isControlledAccount(me)) {
+    throw "me is not a controlled account";
+  }
+
+  me._raw.core.node.syncManager.addPeer(secondPeer);
+  const { account: meOnSecondPeer } =
+    await createJazzContextFromExistingCredentials({
+      credentials: {
+        accountID: me.id,
+        secret: me._raw.core.node.agentSecret,
+      },
+      sessionProvider: randomSessionProvider,
+      peersToLoadFrom: [initialAsPeer],
+      crypto: Crypto,
+    });
+
+  const record = RecordLike.create(
+    {
+      key1: TestMap.create(
+        { list: TestList.create([], { owner: me }) },
+        { owner: me },
+      ),
+      key2: TestMap.create(
+        { list: TestList.create([], { owner: me }) },
+        { owner: me },
+      ),
+    },
+    { owner: me },
+  );
+
+  const recordLoaded = await RecordLike.load(record.id, {
+    loadAs: meOnSecondPeer,
+    resolve: {
+      $each: { list: { $each: true } },
+    },
+  });
+  expectTypeOf(recordLoaded).toEqualTypeOf<
+    | (RecordLike & {
+        [key: string]: TestMap & {
+          list: TestList & InnerMap[];
+        };
+      })
+    | null
+  >();
+});
+
+test("The resolve type doesn't accept extra keys", async () => {
+  const me = await CustomAccount.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const meLoaded = await me.ensureLoaded({
+    resolve: {
+      // @ts-expect-error
+      profile: { stream: true, extraKey: true },
+      // @ts-expect-error
+      root: { list: true, extraKey: true },
+    },
+  });
+
+  expectTypeOf(meLoaded).toEqualTypeOf<
+    CustomAccount & {
+      profile: CustomProfile & {
+        stream: TestStream;
+        extraKey: never;
+      };
+      root: TestMap & {
+        list: TestList;
+        extraKey: never;
+      };
+    }
+  >();
+});

package/src/tests/deepLoading.test.ts

@@ -612,6 +612,254 @@ describe("Deep loading with unauthorized account", async () => {
 
     expect(loadedMap?.id).toBe(map.id);
   });
+
+  test("unaccessible record element with $onError", async () => {
+    class Person extends CoMap {
+      name = co.string;
+    }
+    class Friends extends CoMap.Record(co.ref(Person)) {}
+
+    const map = Friends.create(
+      {
+        jane: Person.create({ name: "Jane" }, onlyBob),
+        alice: Person.create({ name: "Alice" }, group),
+      },
+      group,
+    );
+
+    const friendsOnAlice = await Friends.load(map.id, {
+      resolve: { $each: { $onError: null } },
+      loadAs: alice,
+    });
+
+    assert(friendsOnAlice, "friendsOnAlice is null");
+
+    expect(friendsOnAlice.jane).toBeNull();
+    expect(friendsOnAlice.alice).not.toBeNull();
+  });
+
+  test("unaccessible nested record element with $onError", async () => {
+    class Person extends CoMap {
+      name = co.string;
+    }
+    class Friends extends CoMap.Record(co.ref(Person)) {}
+
+    class User extends CoMap {
+      name = co.string;
+      friends = co.ref(Friends);
+    }
+
+    const map = User.create(
+      {
+        name: "John",
+        friends: Friends.create(
+          {
+            jane: Person.create({ name: "Jane" }, onlyBob),
+            alice: Person.create({ name: "Alice" }, group),
+          },
+          group,
+        ),
+      },
+      group,
+    );
+
+    const user = await User.load(map.id, {
+      resolve: { friends: { $each: { $onError: null } } },
+      loadAs: alice,
+    });
+
+    assert(user, "user is null");
+
+    expect(user.friends.jane).toBeNull();
+    expect(user.friends.alice).not.toBeNull();
+  });
+
+  test("unaccessible element down the chain with $onError on a record", async () => {
+    class Person extends CoMap {
+      name = co.string;
+      dog = co.ref(Dog);
+    }
+    class Dog extends CoMap {
+      name = co.string;
+    }
+    class Friends extends CoMap.Record(co.ref(Person)) {}
+
+    class User extends CoMap {
+      name = co.string;
+      friends = co.ref(Friends);
+    }
+
+    const map = User.create(
+      {
+        name: "John",
+        friends: Friends.create(
+          {
+            jane: Person.create(
+              {
+                name: "Jane",
+                dog: Dog.create({ name: "Rex" }, onlyBob), // Jane dog is inaccessible
+              },
+              group,
+            ),
+            alice: Person.create(
+              { name: "Alice", dog: Dog.create({ name: "Giggino" }, group) },
+              group,
+            ),
+          },
+          group,
+        ),
+      },
+      group,
+    );
+
+    const user = await User.load(map.id, {
+      resolve: { friends: { $each: { dog: true, $onError: null } } },
+      loadAs: alice,
+    });
+
+    assert(user);
+
+    expect(user.friends.jane).toBeNull(); // jane is null because her dog is inaccessible
+    expect(user.friends.alice?.dog).not.toBeNull(); // alice is not null because we have read access to her and her dog
+  });
+
+  test("unaccessible list element with $onError and $each with depth", async () => {
+    class Person extends CoMap {
+      name = co.string;
+      friends = co.optional.ref(Friends);
+    }
+    class Friends extends CoList.Of(co.ref(Person)) {}
+
+    const list = Friends.create(
+      [
+        Person.create(
+          {
+            name: "Jane",
+            friends: Friends.create(
+              [Person.create({ name: "Bob" }, onlyBob)],
+              group,
+            ),
+          },
+          group,
+        ),
+        Person.create(
+          {
+            name: "Alice",
+            friends: Friends.create(
+              [Person.create({ name: "Bob" }, group)],
+              group,
+            ),
+          },
+          group,
+        ),
+      ],
+      group,
+    );
+
+    // The error List -> Jane -> Bob should be propagated to the list element Jane
+    // and we should have [null, Alice]
+    const listOnAlice = await Friends.load(list.id, {
+      resolve: { $each: { friends: { $each: true }, $onError: null } },
+      loadAs: alice,
+    });
+
+    assert(listOnAlice, "listOnAlice is null");
+
+    expect(listOnAlice[0]).toBeNull();
+    expect(listOnAlice[1]).not.toBeNull();
+    expect(listOnAlice[1]?.name).toBe("Alice");
+    expect(listOnAlice[1]?.friends).not.toBeNull();
+    expect(listOnAlice[1]?.friends?.[0]?.name).toBe("Bob");
+    expect(listOnAlice).toHaveLength(2);
+  });
+
+  test("unaccessible record element with $onError", async () => {
+    class Person extends CoMap {
+      name = co.string;
+    }
+    class Friend extends CoMap.Record(co.ref(Person)) {}
+
+    const map = Friend.create(
+      {
+        jane: Person.create({ name: "Jane" }, onlyBob),
+        alice: Person.create({ name: "Alice" }, group),
+      },
+      group,
+    );
+
+    const friendsOnAlice = await Friend.load(map.id, {
+      resolve: { $each: { $onError: null } },
+      loadAs: alice,
+    });
+
+    assert(friendsOnAlice, "friendsOnAlice is null");
+
+    expect(friendsOnAlice.jane).toBeNull();
+    expect(friendsOnAlice.alice).not.toBeNull();
+  });
+
+  test("unaccessible ref catched with $onError", async () => {
+    class Person extends CoMap {
+      name = co.string;
+      dog = co.ref(Dog);
+    }
+    class Dog extends CoMap {
+      name = co.string;
+    }
+    class Friends extends CoMap.Record(co.ref(Person)) {}
+
+    class User extends CoMap {
+      name = co.string;
+      friends = co.ref(Friends);
+    }
+
+    const map = User.create(
+      {
+        name: "John",
+        friends: Friends.create(
+          {
+            jane: Person.create(
+              {
+                name: "Jane",
+                dog: Dog.create({ name: "Rex" }, onlyBob), // Jane dog is inaccessible
+              },
+              group,
+            ),
+            alice: Person.create(
+              { name: "Alice", dog: Dog.create({ name: "Giggino" }, group) },
+              group,
+            ),
+          },
+          group,
+        ),
+      },
+      group,
+    );
+
+    const user = await User.load(map.id, {
+      resolve: { friends: { $each: { dog: { $onError: null } } } },
+      loadAs: alice,
+    });
+
+    assert(user);
+
+    expect(user.friends.jane?.dog).toBeNull(); // jane is null because her dog is inaccessible
+    expect(user.friends.alice?.dog?.name).toBe("Giggino"); // alice is not null because we have read access to her and her dog
+  });
+
+  test("using $onError on the resolve root", async () => {
+    class Person extends CoMap {
+      name = co.string;
+    }
+
+    const map = Person.create({ name: "John" }, onlyBob);
+    const user = await Person.load(map.id, {
+      resolve: { $onError: null },
+      loadAs: alice,
+    });
+
+    expect(user).toBeNull();
+  });
 });
 
 test("doesn't break on Map.Record key deletion when the key is referenced in the depth", async () => {
@@ -689,6 +937,7 @@ test("throw when calling ensureLoaded on a ref that is not defined in the schema
 
   await expect(
     root.ensureLoaded({
+      // @ts-expect-error missing required ref
       resolve: { profile: true },
     }),
   ).rejects.toThrow("Failed to deeply load CoValue " + root.id);