jazz-tools 0.13.30 → 0.14.0

package/src/tests/deepLoading.test.ts

@@ -1,42 +1,43 @@
-import { cojsonInternals } from "cojson";
+import { Profile, 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,
+  z,
 } from "../index.js";
-import { randomSessionProvider } from "../internal.js";
+import {
+  Account,
+  CoListSchema,
+  Loaded,
+  co,
+  randomSessionProvider,
+} from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 import { waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 const { connectedPeers } = cojsonInternals;
 
-class TestMap extends CoMap {
-  list = co.ref(TestList);
-  optionalRef = co.ref(InnermostMap, { optional: true });
-}
+const InnermostMap = co.map({
+  value: z.string(),
+});
 
-class TestList extends CoList.Of(co.ref(() => InnerMap)) {}
+const TestFeed = co.feed(InnermostMap);
 
-class InnerMap extends CoMap {
-  stream = co.ref(TestStream);
-}
+const InnerMap = co.map({
+  stream: TestFeed,
+});
 
-class TestStream extends CoFeed.Of(co.ref(() => InnermostMap)) {}
+const TestList = co.list(InnerMap);
 
-class InnermostMap extends CoMap {
-  value = co.string;
-}
+const TestMap = co.map({
+  list: TestList,
+  optionalRef: z.optional(InnermostMap),
+});
 
 describe("Deep loading with depth arg", async () => {
   const me = await Account.create({
@@ -71,7 +72,7 @@ describe("Deep loading with depth arg", async () => {
         [
           InnerMap.create(
             {
-              stream: TestStream.create(
+              stream: TestFeed.create(
                 [InnermostMap.create({ value: "hello" }, ownership)],
                 ownership,
               ),
@@ -87,7 +88,7 @@ describe("Deep loading with depth arg", async () => {
 
   test("load without resolve", async () => {
     const map1 = await TestMap.load(map.id, { loadAs: meOnSecondPeer });
-    expectTypeOf(map1).toEqualTypeOf<TestMap | null>();
+    expectTypeOf(map1).branded.toEqualTypeOf<Loaded<typeof TestMap> | null>();
 
     assert(map1, "map1 is null");
 
@@ -99,9 +100,9 @@ describe("Deep loading with depth arg", async () => {
       loadAs: meOnSecondPeer,
       resolve: { list: true },
     });
-    expectTypeOf(map2).toEqualTypeOf<
-      | (TestMap & {
-          list: TestList;
+    expectTypeOf(map2).branded.toEqualTypeOf<
+      | (Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList>;
         })
       | null
     >();
@@ -115,9 +116,9 @@ describe("Deep loading with depth arg", async () => {
       loadAs: meOnSecondPeer,
       resolve: { list: { $each: true } },
     });
-    expectTypeOf(map3).toEqualTypeOf<
-      | (TestMap & {
-          list: TestList & InnerMap[];
+    expectTypeOf(map3).branded.toEqualTypeOf<
+      | (Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList> & Loaded<typeof InnerMap>[];
         })
       | null
     >();
@@ -131,9 +132,9 @@ describe("Deep loading with depth arg", async () => {
       loadAs: meOnSecondPeer,
       resolve: { optionalRef: true } as const,
     });
-    expectTypeOf(map3a).toEqualTypeOf<
-      | (TestMap & {
-          optionalRef: InnermostMap | undefined;
+    expectTypeOf(map3a).branded.toEqualTypeOf<
+      | (Loaded<typeof TestMap> & {
+          optionalRef: Loaded<typeof InnermostMap> | undefined;
         })
       | null
     >();
@@ -146,15 +147,16 @@ describe("Deep loading with depth arg", async () => {
       loadAs: meOnSecondPeer,
       resolve: { list: { $each: { stream: true } } },
     });
-    expectTypeOf(map4).toEqualTypeOf<
-      | (TestMap & {
-          list: TestList & (InnerMap & { stream: TestStream })[];
+    expectTypeOf(map4).branded.toEqualTypeOf<
+      | (Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList> &
+            (Loaded<typeof InnerMap> & { stream: Loaded<typeof TestFeed> })[];
         })
       | 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?.perAccount[me.id]).toBeTruthy();
     expect(map4.list[0]?.stream?.byMe?.value).toBe(null);
   });
 
@@ -164,73 +166,76 @@ describe("Deep loading with depth arg", async () => {
       resolve: { list: { $each: { stream: { $each: true } } } },
     });
     type ExpectedMap5 =
-      | (TestMap & {
-          list: TestList &
-            (InnerMap & {
-              stream: TestStream & {
-                byMe?: { value: InnermostMap };
-                inCurrentSession?: { value: InnermostMap };
+      | (Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList> &
+            (Loaded<typeof InnerMap> & {
+              stream: Loaded<typeof TestFeed> & {
+                byMe?: { value: Loaded<typeof InnermostMap> };
+                inCurrentSession?: { value: Loaded<typeof InnermostMap> };
                 perSession: {
                   [sessionID: SessionID]: {
-                    value: InnermostMap;
+                    value: Loaded<typeof InnermostMap>;
                   };
                 };
               } & {
-                [key: ID<Account>]: { value: InnermostMap };
+                [key: ID<Account>]: { value: Loaded<typeof InnermostMap> };
               };
             })[];
         })
       | null;
-    expectTypeOf(map5).toEqualTypeOf<ExpectedMap5>();
+    expectTypeOf(map5).branded.toEqualTypeOf<ExpectedMap5>();
     assert(map5, "map5 is null");
 
-    expect(map5.list[0]?.stream?.[me.id]?.value).toBeTruthy();
+    expect(map5.list[0]?.stream?.perAccount[me.id]?.value).toBeTruthy();
     expect(map5.list[0]?.stream?.byMe?.value).toBeTruthy();
   });
 });
 
-class CustomProfile extends Profile {
-  stream = co.ref(TestStream);
-}
-
-class CustomAccount extends Account {
-  profile = co.ref(CustomProfile);
-  root = co.ref(TestMap);
+const CustomProfile = co.profile({
+  name: z.string(),
+  stream: TestFeed,
+});
 
-  async migrate(
-    this: CustomAccount,
-    creationProps?: { name: string } | undefined,
-  ) {
+const CustomAccount = co
+  .account({
+    profile: CustomProfile,
+    root: TestMap,
+  })
+  .withMigration(async (account, creationProps) => {
     if (creationProps) {
-      const profileGroup = Group.create(this);
-      this.profile = CustomProfile.create(
+      const profileGroup = Group.create(account);
+      account.profile = CustomProfile.create(
         {
           name: creationProps.name,
-          stream: TestStream.create([], this),
+          stream: TestFeed.create([], account),
         },
         profileGroup,
       );
-      this.root = TestMap.create({ list: TestList.create([], this) }, this);
+      account.root = TestMap.create(
+        { list: TestList.create([], account) },
+        account,
+      );
     }
 
-    const thisLoaded = await this.ensureLoaded({
+    const accountLoaded = await account.ensureLoaded({
       resolve: {
         profile: { stream: true },
         root: { list: true },
       },
     });
-    expectTypeOf(thisLoaded).toEqualTypeOf<
-      CustomAccount & {
-        profile: CustomProfile & {
-          stream: TestStream;
-        };
-        root: TestMap & {
-          list: TestList;
-        };
-      }
-    >();
-  }
-}
+
+    // using assignment to check type compatibility
+    const _T:
+      | (Loaded<typeof CustomAccount> & {
+          profile: Loaded<typeof CustomProfile> & {
+            stream: Loaded<typeof TestFeed>;
+          };
+          root: Loaded<typeof TestMap> & {
+            list: Loaded<typeof TestList>;
+          };
+        })
+      | null = accountLoaded;
+  });
 
 test("Deep loading within account", async () => {
   const me = await CustomAccount.create({
@@ -244,22 +249,24 @@ test("Deep loading within account", async () => {
       root: { list: true },
     },
   });
-  expectTypeOf(meLoaded).toEqualTypeOf<
-    CustomAccount & {
-      profile: CustomProfile & {
-        stream: TestStream;
-      };
-      root: TestMap & {
-        list: TestList;
-      };
-    }
-  >();
+
+  // using assignment to check type compatibility
+  const _T:
+    | (Loaded<typeof CustomAccount> & {
+        profile: Loaded<typeof CustomProfile> & {
+          stream: Loaded<typeof TestFeed>;
+        };
+        root: Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList>;
+        };
+      })
+    | null = meLoaded;
 
   expect(meLoaded.profile.stream).toBeTruthy();
   expect(meLoaded.root.list).toBeTruthy();
 });
 
-class RecordLike extends CoMap.Record(co.ref(TestMap)) {}
+const RecordLike = co.record(z.string(), TestMap);
 
 test("Deep loading a record-like coMap", async () => {
   const me = await Account.create({
@@ -309,9 +316,9 @@ test("Deep loading a record-like coMap", async () => {
     },
   });
   expectTypeOf(recordLoaded).toEqualTypeOf<
-    | (RecordLike & {
-        [key: string]: TestMap & {
-          list: TestList & InnerMap[];
+    | (Loaded<typeof RecordLike> & {
+        [key: string]: Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList> & Loaded<typeof InnerMap>[];
         };
       })
     | null
@@ -356,18 +363,19 @@ test("The resolve type doesn't accept extra keys", async () => {
       },
     });
 
-    expectTypeOf(meLoaded).toEqualTypeOf<
-      CustomAccount & {
-        profile: CustomProfile & {
-          stream: TestStream;
-          extraKey: never;
-        };
-        root: TestMap & {
-          list: TestList;
-          extraKey: never;
-        };
-      }
-    >();
+    // using assignment to check type compatibility
+    const _T:
+      | (Loaded<typeof CustomAccount> & {
+          profile: Loaded<typeof CustomProfile> & {
+            stream: Loaded<typeof TestFeed>;
+            extraKey: never;
+          };
+          root: Loaded<typeof TestMap> & {
+            list: Loaded<typeof TestList>;
+            extraKey: never;
+          };
+        })
+      | null = meLoaded;
   } catch (e) {
     expect(e).toBeInstanceOf(Error);
   }
@@ -438,7 +446,7 @@ describe("Deep loading with unauthorized account", async () => {
           [
             InnerMap.create(
               {
-                stream: TestStream.create([], group),
+                stream: TestFeed.create([], group),
               },
               onlyBob,
             ),
@@ -524,7 +532,7 @@ describe("Deep loading with unauthorized account", async () => {
           [
             InnerMap.create(
               {
-                stream: TestStream.create([], onlyBob),
+                stream: TestFeed.create([], onlyBob),
               },
               group,
             ),
@@ -560,7 +568,7 @@ describe("Deep loading with unauthorized account", async () => {
           [
             InnerMap.create(
               {
-                stream: TestStream.create([value], group),
+                stream: TestFeed.create([value], group),
               },
               group,
             ),
@@ -585,25 +593,25 @@ describe("Deep loading with unauthorized account", async () => {
     errorSpy.mockReset();
   });
 
-  test("setting null via proxy", async () => {
-    class Lv1 extends CoMap {
-      lv2 = co.ref(Lv2);
-    }
+  test("setting undefined via proxy", async () => {
+    const Lv3 = co.map({
+      string: z.string(),
+    });
 
-    class Lv2 extends CoMap {
-      lv3 = co.optional.ref(Lv3);
-    }
+    const Lv2 = co.map({
+      lv3: z.optional(Lv3),
+    });
 
-    class Lv3 extends CoMap {
-      string = co.string;
-    }
+    const Lv1 = co.map({
+      lv2: Lv2,
+    });
 
     const map = Lv1.create(
       { lv2: Lv2.create({ lv3: Lv3.create({ string: "hello" }, bob) }, bob) },
       bob,
     );
 
-    map.lv2!.lv3 = null;
+    map.lv2!.lv3 = undefined;
 
     const loadedMap = await Lv1.load(map.id, {
       resolve: { lv2: { lv3: true } },
@@ -612,18 +620,273 @@ describe("Deep loading with unauthorized account", async () => {
 
     expect(loadedMap?.id).toBe(map.id);
   });
+
+  test("unaccessible record element with $onError", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Friends = co.record(z.string(), 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 () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Friends = co.record(z.string(), Person);
+
+    const User = co.map({
+      name: z.string(),
+      friends: 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 () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      dog: Dog,
+    });
+
+    const Friends = co.record(z.string(), Person);
+
+    const User = co.map({
+      name: z.string(),
+      friends: 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 () => {
+    const Person = co.map({
+      name: z.string(),
+      get friends(): z.ZodOptional<typeof Friends> {
+        return z.optional(Friends);
+      },
+    });
+    const Friends: CoListSchema<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate
+
+    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 () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Friend = co.record(z.string(), 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 () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      dog: Dog,
+    });
+
+    const Friends = co.record(z.string(), Person);
+
+    const User = co.map({
+      name: z.string(),
+      friends: 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 () => {
+    const Person = co.map({
+      name: z.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 () => {
-  class JazzProfile extends CoMap {
-    firstName = co.string;
-  }
+  const JazzProfile = co.map({
+    name: z.string(),
+    firstName: z.string(),
+  });
 
-  class JazzySnapStore extends CoMap.Record(co.ref(JazzProfile)) {}
+  const JazzySnapStore = co.record(z.string(), JazzProfile);
 
   const snapStore = JazzySnapStore.create({
-    profile1: JazzProfile.create({ firstName: "John" }),
-    profile2: JazzProfile.create({ firstName: "John" }),
+    profile1: JazzProfile.create({ name: "John", firstName: "John" }),
+    profile2: JazzProfile.create({ name: "John", firstName: "John" }),
   });
 
   const spy = vi.fn();
@@ -651,13 +914,14 @@ test("doesn't break on Map.Record key deletion when the key is referenced in the
 });
 
 test("throw when calling ensureLoaded on a ref that's required but missing", async () => {
-  class JazzProfile extends CoMap {
-    firstName = co.string;
-  }
+  const JazzProfile = co.map({
+    name: z.string(),
+    firstName: z.string(),
+  });
 
-  class JazzRoot extends CoMap {
-    profile = co.ref(JazzProfile);
-  }
+  const JazzRoot = co.map({
+    profile: JazzProfile,
+  });
 
   const me = await Account.create({
     creationProps: { name: "Tester McTesterson" },
@@ -678,7 +942,7 @@ test("throw when calling ensureLoaded on a ref that's required but missing", asy
 });
 
 test("throw when calling ensureLoaded on a ref that is not defined in the schema", async () => {
-  class JazzRoot extends CoMap {}
+  const JazzRoot = co.map({});
 
   const me = await Account.create({
     creationProps: { name: "Tester McTesterson" },
@@ -689,17 +953,19 @@ 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);
 });
 
 test("should not throw when calling ensureLoaded a record with a deleted ref", async () => {
-  class JazzProfile extends CoMap {
-    firstName = co.string;
-  }
+  const JazzProfile = co.map({
+    name: z.string(),
+    firstName: z.string(),
+  });
 
-  class JazzySnapStore extends CoMap.Record(co.ref(JazzProfile)) {}
+  const JazzySnapStore = co.record(z.string(), JazzProfile);
 
   const me = await Account.create({
     creationProps: { name: "Tester McTesterson" },
@@ -708,7 +974,7 @@ test("should not throw when calling ensureLoaded a record with a deleted ref", a
 
   const root = JazzySnapStore.create(
     {
-      profile: JazzProfile.create({ firstName: "John" }, me),
+      profile: JazzProfile.create({ name: "John", firstName: "John" }, me),
     },
     me,
   );