jazz-tools 0.18.38 → 0.19.0

package/src/tools/tests/coList.branch.test.ts

@@ -3,7 +3,7 @@ import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 import { Group, co, z } from "../exports.js";
 
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { waitFor } from "./utils.js";
+import { assertLoaded, waitFor } from "./utils.js";
 
 beforeEach(async () => {
   cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 1000;
@@ -36,7 +36,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "feature-branch" },
       });
 
-      assert(branchList);
+      assertLoaded(branchList);
 
       // Edit the branch
       branchList.$jazz.set(0, "Buy organic groceries");
@@ -83,7 +83,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "feature-branch" },
       });
 
-      assert(branchList);
+      assertLoaded(branchList);
 
       // Edit the branch
       branchList.$jazz.set(0, "Buy organic groceries");
@@ -130,7 +130,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "no-changes-branch" },
       });
 
-      assert(branchList);
+      assertLoaded(branchList);
 
       // Verify branch has same values as original
       expect(branchList[0]).toBe("Buy groceries");
@@ -164,7 +164,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "shared-branch" },
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       branch1.$jazz.set(0, "Buy organic groceries");
       branch1.$jazz.push("Call mom");
@@ -174,7 +174,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "shared-branch" },
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       // Both branches should have the same changes
       expect(branch1[0]).toBe("Buy organic groceries");
@@ -219,7 +219,7 @@ describe("CoList Branching", async () => {
         loadAs: alice,
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       originalList.$jazz.set(0, "Buy organic groceries");
       originalList.$jazz.push("Call mom");
@@ -230,7 +230,7 @@ describe("CoList Branching", async () => {
         loadAs: bob,
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       // Both branches should have the same changes
       expect(branch1[0]).toBe("Buy groceries");
@@ -280,7 +280,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "double-merge-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.set(0, "Buy organic groceries");
       branch.$jazz.push("Call mom");
@@ -324,7 +324,7 @@ describe("CoList Branching", async () => {
         loadAs: alice,
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       branch1.$jazz.set(0, "Buy organic groceries");
 
@@ -334,7 +334,7 @@ describe("CoList Branching", async () => {
         loadAs: bob,
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       branch2.$jazz.set(1, "Walk the cat");
       branch2.$jazz.push("Schedule dentist");
@@ -385,7 +385,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "load-by-id-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       expect(branch.$jazz.id).toBe(originalList.$jazz.id);
     });
@@ -406,7 +406,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "conflict-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.set(0, "Buy organic groceries");
       branch.$jazz.set(1, "Walk the cat");
@@ -445,7 +445,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "align-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.set(0, "Buy organic groceries");
 
@@ -463,7 +463,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "align-branch" },
       });
 
-      assert(loadedBranch);
+      assertLoaded(loadedBranch);
 
       expect(loadedBranch[0]).toBe("Buy organic groceries");
       expect(loadedBranch[1]).toBe("Walk the dog");
@@ -503,7 +503,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "task-list-edit" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       // Make extensive changes to the branch
       branch.$jazz.set(0, {
@@ -529,7 +529,7 @@ describe("CoList Branching", async () => {
         },
       });
 
-      assert(loadedTaskList);
+      assertLoaded(loadedTaskList);
 
       // Verify original is unchanged
       expect(loadedTaskList[0]!.title).toBe("Buy groceries");
@@ -592,7 +592,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "subscribe-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       const spy = vi.fn();
       branch.$jazz.subscribe(
@@ -666,7 +666,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "ensure-loaded-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.set(0, {
         title: "Buy organic groceries",
@@ -737,7 +737,7 @@ describe("CoList Branching", async () => {
         unstable_branch: { name: "schema-subscribe-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.set(0, {
         title: "Buy organic groceries",
@@ -751,7 +751,7 @@ describe("CoList Branching", async () => {
       });
 
       // Subscribe using Schema.subscribe with branch
-      const updates: co.loaded<typeof TaskList, true>[] = [];
+      const updates: co.loaded<typeof TaskList, { $each: true }>[] = [];
       const unsubscribe = TaskList.subscribe(
         originalTaskList.$jazz.id,
         {

package/src/tools/tests/coList.test-d.ts

@@ -1,7 +1,8 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
-import { CoList, CoMap, Loaded } from "../internal.js";
+import { CoList, CoMap, Loaded, MaybeLoaded } from "../internal.js";
+import { assertLoaded } from "./utils.js";
 
 describe("CoList", () => {
   describe("init", () => {
@@ -199,7 +200,7 @@ describe("CoList", () => {
         },
       });
 
-      type ExpectedType = ReadonlyArray<Loaded<typeof Dog>> | null;
+      type ExpectedType = MaybeLoaded<ReadonlyArray<Loaded<typeof Dog>>>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -207,7 +208,7 @@ describe("CoList", () => {
 
       matches(loadedList);
 
-      assert(loadedList);
+      assertLoaded(loadedList);
       const firstDog = loadedList[0];
       assert(firstDog);
       expectTypeOf(firstDog.name).toEqualTypeOf<string>();
@@ -228,11 +229,13 @@ describe("CoList", () => {
 
       const loadedList = await DogList.load(list.$jazz.id, {
         resolve: {
-          $each: { $onError: null },
+          $each: { $onError: "catch" },
         },
       });
 
-      type ExpectedType = ReadonlyArray<Loaded<typeof Dog> | null> | null;
+      type ExpectedType = MaybeLoaded<
+        ReadonlyArray<MaybeLoaded<Loaded<typeof Dog>>>
+      >;
 
       function matches(value: ExpectedType) {
         return value;
@@ -265,9 +268,9 @@ describe("CoList", () => {
         },
       });
 
-      type ExpectedType = ReadonlyArray<
-        ReadonlyArray<Loaded<typeof Dog>>
-      > | null;
+      type ExpectedType = MaybeLoaded<
+        ReadonlyArray<ReadonlyArray<Loaded<typeof Dog>>>
+      >;
 
       function matches(value: ExpectedType) {
         return value;
@@ -275,7 +278,7 @@ describe("CoList", () => {
 
       matches(loadedList);
 
-      assert(loadedList);
+      assertLoaded(loadedList);
       const firstList = loadedList[0];
       assert(firstList);
       const firstDog = firstList[0];
@@ -305,22 +308,23 @@ describe("CoList", () => {
       });
 
       const loadedPerson = await Person.load(person.$jazz.id, {
-        resolve: { dogs: { $onError: null } },
+        resolve: { dogs: { $onError: "catch" } },
       });
 
-      type ExpectedType =
-        | ({
-            name: string;
-            age: number;
-            dogs: CoList<
-              | ({
-                  name: string;
-                  breed: string;
-                } & CoMap)
-              | null
-            > | null;
-          } & CoMap)
-        | null;
+      type ExpectedType = MaybeLoaded<
+        {
+          name: string;
+          age: number;
+          dogs: MaybeLoaded<
+            CoList<
+              {
+                name: string;
+                breed: string;
+              } & CoMap
+            >
+          >;
+        } & CoMap
+      >;
 
       function matches(value: ExpectedType) {
         return value;
@@ -328,5 +332,17 @@ describe("CoList", () => {
 
       matches(loadedPerson);
     });
+
+    test("cannot use $each is resolve queries of CoLists that contains non-collaborative values", () => {
+      const ListOfNumbers = co.list(z.number());
+      ListOfNumbers.load("list-id", {
+        resolve: {
+          // @ts-expect-error `$each` is not allowd
+          $each: true,
+          // `$onError` is allowed
+          $onError: "catch",
+        },
+      });
+    });
   });
 });

package/src/tools/tests/coList.test.ts

@@ -6,13 +6,14 @@ import {
   activeAccountContext,
   co,
   coValueClassFromCoValueClassOrSchema,
+  CoValueLoadingState,
 } from "../internal.js";
 import {
   createJazzTestAccount,
   runWithoutActiveAccount,
   setupJazzTestSync,
 } from "../testing.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { assertLoaded, setupTwoNodes, waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -275,8 +276,8 @@ describe("Simple CoList operations", async () => {
           resolve: { $each: { title: true } },
         });
 
-        assert(loadedTask);
-        assert(loadedTaskList);
+        assertLoaded(loadedTask);
+        assertLoaded(loadedTaskList);
         // @ts-expect-error loadedTask may not have its `title` loaded
         loadedTaskList.$jazz.push(loadedTask);
         // In this case the title is loaded, so the assertion passes
@@ -467,7 +468,7 @@ describe("Simple CoList operations", async () => {
         const onion = list[2];
 
         const shallowlyLoadedList = await NestedList.load(list.$jazz.id);
-        assert(shallowlyLoadedList);
+        assertLoaded(shallowlyLoadedList);
 
         const loadedList = await shallowlyLoadedList.$jazz.ensureLoaded({
           resolve: { $each: true },
@@ -771,16 +772,15 @@ describe("CoList resolution", async () => {
       loadAs: userB,
     });
 
-    assert(loadedPets);
+    assertLoaded(loadedPets);
 
     const petReference = loadedPets.$jazz.refs[0];
-    expect(petReference).toBeDefined();
-    expect(petReference?.id).toBe(pets[0]?.$jazz.id);
+    assert(petReference);
+    expect(petReference.id).toBe(pets[0]?.$jazz.id);
 
-    const dog = await petReference?.load();
-
-    assert(dog);
+    const dog = await petReference.load();
 
+    assertLoaded(dog);
     expect(dog.name).toEqual("Rex");
   });
 
@@ -798,7 +798,7 @@ describe("CoList resolution", async () => {
 
     const loadedMap = await serverNode.load(list.$jazz.raw.id);
 
-    expect(loadedMap).not.toBe("unavailable");
+    expect(loadedMap).not.toBe(CoValueLoadingState.UNAVAILABLE);
   });
 });
 
@@ -870,15 +870,23 @@ describe("CoList subscription", async () => {
 
     expect(spy).toHaveBeenCalledTimes(1);
 
-    expect(updates[0]?.[0]?.name).toEqual("Item 1");
+    assert(updates[0]?.[0]);
+    assertLoaded(updates[0][0]);
+    expect(updates[0][0].name).toEqual("Item 1");
+    assert(updates[0]?.[1]);
+    assertLoaded(updates[0][1]);
     expect(updates[0]?.[1]?.name).toEqual("Item 2");
 
     list[0]!.$jazz.set("name", "Updated Item 1");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
-    expect(updates[1]?.[0]?.name).toEqual("Updated Item 1");
-    expect(updates[1]?.[1]?.name).toEqual("Item 2");
+    assert(updates[1]?.[0]);
+    assertLoaded(updates[1][0]);
+    expect(updates[1][0].name).toEqual("Updated Item 1");
+    assert(updates[1]?.[1]);
+    assertLoaded(updates[1][1]);
+    expect(updates[1][1].name).toEqual("Item 2");
 
     expect(spy).toHaveBeenCalledTimes(2);
   });
@@ -911,8 +919,12 @@ describe("CoList subscription", async () => {
     expect(spy).toHaveBeenCalled();
     expect(spy).toHaveBeenCalledTimes(1);
 
-    expect(updates[0]?.[0]?.name).toEqual("Item 1");
-    expect(updates[0]?.[1]?.name).toEqual("Item 2");
+    assert(updates[0]?.[0]);
+    assertLoaded(updates[0][0]);
+    expect(updates[0][0].name).toEqual("Item 1");
+    assert(updates[0]?.[1]);
+    assertLoaded(updates[0][1]);
+    expect(updates[0][1].name).toEqual("Item 2");
 
     expect(spy).toHaveBeenCalledTimes(1);
 
@@ -920,8 +932,12 @@ describe("CoList subscription", async () => {
 
     expect(spy).toHaveBeenCalledTimes(2);
 
-    expect(updates[1]?.[0]?.name).toEqual("Updated Item 1");
-    expect(updates[1]?.[1]?.name).toEqual("Item 2");
+    assert(updates[1]?.[0]);
+    assertLoaded(updates[1][0]);
+    expect(updates[1][0].name).toEqual("Updated Item 1");
+    assert(updates[1]?.[1]);
+    assertLoaded(updates[1][1]);
+    expect(updates[1][1].name).toEqual("Item 2");
 
     expect(spy).toHaveBeenCalledTimes(2);
   });
@@ -1017,16 +1033,24 @@ describe("CoList subscription", async () => {
     expect(spy).toHaveBeenCalledTimes(1);
 
     await waitFor(() => {
-      expect(updates[0]?.[0]?.name).toEqual("Item 1");
-      expect(updates[0]?.[1]?.name).toEqual("Item 2");
+      assert(updates[0]?.[0]);
+      assertLoaded(updates[0][0]);
+      expect(updates[0][0].name).toEqual("Item 1");
+      assert(updates[0]?.[1]);
+      assertLoaded(updates[0][1]);
+      expect(updates[0][1].name).toEqual("Item 2");
     });
 
     list[0]!.$jazz.set("name", "Updated Item 1");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(4));
 
-    expect(updates[1]?.[0]?.name).toEqual("Updated Item 1");
-    expect(updates[1]?.[1]?.name).toEqual("Item 2");
+    assert(updates[1]?.[0]);
+    assertLoaded(updates[1][0]);
+    expect(updates[1][0].name).toEqual("Updated Item 1");
+    assert(updates[1]?.[1]);
+    assertLoaded(updates[1][1]);
+    expect(updates[1][1].name).toEqual("Item 2");
 
     expect(spy).toHaveBeenCalledTimes(4);
   });
@@ -1154,13 +1178,15 @@ describe("CoList subscription", async () => {
     const bob = await createJazzTestAccount();
 
     const loadedPerson = await Person.load(person.$jazz.id, {
-      resolve: { dogs: { $onError: null } },
+      resolve: { dogs: { $onError: "catch" } },
       loadAs: bob,
     });
 
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
     expect(loadedPerson.name).toBe("John");
-    expect(loadedPerson.dogs).toBeNull();
+    expect(loadedPerson.dogs.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
   });
 });
 

package/src/tools/tests/coList.unique.test.ts

@@ -2,12 +2,14 @@ import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 import { Account, Group, subscribeToCoValue, z } from "../index.js";
 import {
+  CoValueLoadingState,
   Loaded,
   activeAccountContext,
   co,
   coValueClassFromCoValueClassOrSchema,
 } from "../internal.js";
 import {
+  assertLoaded,
   createJazzTestAccount,
   runWithoutActiveAccount,
   setupJazzTestSync,
@@ -41,17 +43,18 @@ describe("CoList unique methods", () => {
     });
 
     const foundList = await ItemList.loadUnique("test-list", group.$jazz.id);
+    assertLoaded(foundList);
     expect(foundList).toEqual(originalList);
     expect(foundList?.length).toBe(3);
     expect(foundList?.[0]).toBe("item1");
   });
 
-  test("loadUnique returns null for non-existent list", async () => {
+  test("loadUnique returns 'unavailable' for non-existent list", async () => {
     const ItemList = co.list(z.string());
     const group = Group.create();
 
     const foundList = await ItemList.loadUnique("non-existent", group.$jazz.id);
-    expect(foundList).toBeNull();
+    expect(foundList.$jazz.loadingState).toBe(CoValueLoadingState.UNAVAILABLE);
   });
 
   test("upsertUnique creates new list when none exists", async () => {
@@ -66,11 +69,11 @@ describe("CoList unique methods", () => {
       owner: group,
     });
 
-    expect(result).not.toBeNull();
-    expect(result?.length).toBe(3);
-    expect(result?.[0]).toBe("item1");
-    expect(result?.[1]).toBe("item2");
-    expect(result?.[2]).toBe("item3");
+    assertLoaded(result);
+    expect(result.length).toBe(3);
+    expect(result[0]).toBe("item1");
+    expect(result[1]).toBe("item2");
+    expect(result[2]).toBe("item3");
   });
 
   test("upsertUnique without an active account", async () => {
@@ -87,13 +90,13 @@ describe("CoList unique methods", () => {
       });
     });
 
-    expect(result).not.toBeNull();
-    expect(result?.length).toBe(3);
-    expect(result?.[0]).toBe("item1");
-    expect(result?.[1]).toBe("item2");
-    expect(result?.[2]).toBe("item3");
+    assertLoaded(result);
+    expect(result.length).toBe(3);
+    expect(result[0]).toBe("item1");
+    expect(result[1]).toBe("item2");
+    expect(result[2]).toBe("item3");
 
-    expect(result?.$jazz.owner).toEqual(account);
+    expect(result.$jazz.owner).toEqual(account);
   });
 
   test("upsertUnique updates existing list", async () => {
@@ -113,11 +116,12 @@ describe("CoList unique methods", () => {
       owner: group,
     });
 
+    assertLoaded(updatedList);
     expect(updatedList).toEqual(originalList); // Should be the same instance
-    expect(updatedList?.length).toBe(3);
-    expect(updatedList?.[0]).toBe("updated1");
-    expect(updatedList?.[1]).toBe("updated2");
-    expect(updatedList?.[2]).toBe("updated3");
+    expect(updatedList.length).toBe(3);
+    expect(updatedList[0]).toBe("updated1");
+    expect(updatedList[1]).toBe("updated2");
+    expect(updatedList[2]).toBe("updated3");
   });
 
   test("upsertUnique with CoValue items", async () => {
@@ -140,10 +144,10 @@ describe("CoList unique methods", () => {
       resolve: { $each: true },
     });
 
-    expect(result).not.toBeNull();
-    expect(result?.length).toBe(2);
-    expect(result?.[0]?.name).toBe("First");
-    expect(result?.[1]?.name).toBe("Second");
+    assertLoaded(result);
+    expect(result.length).toBe(2);
+    expect(result[0]?.name).toBe("First");
+    expect(result[1]?.name).toBe("Second");
   });
 
   test("upsertUnique updates list with CoValue items", async () => {
@@ -174,10 +178,11 @@ describe("CoList unique methods", () => {
       resolve: { $each: true },
     });
 
+    assertLoaded(updatedList);
     expect(updatedList).toEqual(originalList); // Should be the same instance
-    expect(updatedList?.length).toBe(2);
-    expect(updatedList?.[0]?.name).toBe("Updated");
-    expect(updatedList?.[1]?.name).toBe("Added");
+    expect(updatedList.length).toBe(2);
+    expect(updatedList[0]?.name).toBe("Updated");
+    expect(updatedList[1]?.name).toBe("Added");
   });
 
   test("findUnique returns correct ID", async () => {
@@ -213,10 +218,10 @@ describe("CoList unique methods", () => {
       resolve: { $each: { category: true } },
     });
 
-    expect(result).not.toBeNull();
-    expect(result?.length).toBe(1);
-    expect(result?.[0]?.name).toBe("Item 1");
-    expect(result?.[0]?.category?.title).toBe("Category 1");
+    assertLoaded(result);
+    expect(result.length).toBe(1);
+    expect(result[0]?.name).toBe("Item 1");
+    expect(result[0]?.category?.title).toBe("Category 1");
   });
 
   test("concurrently upserting the same value", async () => {
@@ -235,7 +240,7 @@ describe("CoList unique methods", () => {
     await Promise.all(promises);
 
     const result = await ItemList.loadUnique("concurrent", owner.$jazz.id);
-    assert(result);
+    assertLoaded(result);
 
     expect(result.length).toBe(2);
     expect(result[0]).toBe(`Item 2`);