jazz-tools 0.18.38 → 0.19.0

package/src/tools/tests/coFeed.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;
@@ -40,7 +40,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "feature-branch" },
       });
 
-      assert(branchFeed);
+      assertLoaded(branchFeed);
 
       expect(branchFeed.$jazz.branchName).toBe("feature-branch");
       expect(branchFeed.$jazz.isBranched).toBe(true);
@@ -84,7 +84,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "feature-branch" },
       });
 
-      assert(branchFeed);
+      assertLoaded(branchFeed);
 
       expect(branchFeed.$jazz.branchName).toBe("feature-branch");
       expect(branchFeed.$jazz.isBranched).toBe(true);
@@ -129,7 +129,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "no-changes-branch" },
       });
 
-      assert(branchFeed);
+      assertLoaded(branchFeed);
 
       expect(branchFeed.$jazz.branchName).toBe("no-changes-branch");
       expect(branchFeed.$jazz.isBranched).toBe(true);
@@ -159,7 +159,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "shared-branch" },
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       branch1.$jazz.push("jam");
 
@@ -167,7 +167,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "shared-branch" },
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       expect(branch1.perAccount[me.$jazz.id]?.value).toEqual("jam");
       expect(branch2.perAccount[me.$jazz.id]?.value).toEqual("jam");
@@ -202,7 +202,7 @@ describe("CoFeed Branching", async () => {
         loadAs: alice,
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       originalFeed.$jazz.push("jam");
 
@@ -212,7 +212,7 @@ describe("CoFeed Branching", async () => {
         loadAs: bob,
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       // Both branches should have the same changes
       expect(branch1.perAccount[me.$jazz.id]?.value).toEqual("butter");
@@ -253,7 +253,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "double-merge-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.push("jam");
 
@@ -261,7 +261,7 @@ describe("CoFeed Branching", async () => {
       branch.$jazz.unstable_merge();
 
       const feed = await TestStream.load(originalFeed.$jazz.id);
-      assert(feed);
+      assertLoaded(feed);
 
       if (feed.perAccount[me.$jazz.id]?.value !== "jam") {
         console.log(feed.$jazz.raw.items, feed.perAccount[me.$jazz.id]?.value);
@@ -299,7 +299,7 @@ describe("CoFeed Branching", async () => {
         loadAs: alice,
       });
 
-      assert(branch1);
+      assertLoaded(branch1);
 
       branch1.$jazz.push("jam");
 
@@ -309,7 +309,7 @@ describe("CoFeed Branching", async () => {
         loadAs: bob,
       });
 
-      assert(branch2);
+      assertLoaded(branch2);
 
       branch2.$jazz.push("cheese");
       branch2.$jazz.push("honey");
@@ -349,8 +349,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "load-by-id-branch" },
       });
 
-      assert(branch);
-
+      assertLoaded(branch);
       expect(branch.$jazz.id).toBe(originalFeed.$jazz.id);
     });
 
@@ -366,7 +365,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "conflict-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.push("jam");
       branch.$jazz.push("cheese");
@@ -398,7 +397,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "align-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.push("jam");
 
@@ -414,7 +413,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "align-branch" },
       });
 
-      assert(loadedBranch);
+      assertLoaded(loadedBranch);
 
       expect(loadedBranch.perAccount[me.$jazz.id]?.value).toEqual("jam");
     });
@@ -437,7 +436,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "text-feed-edit" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       // Make extensive changes to the branch
       branch.$jazz.push(Text.create("jam"));
@@ -449,7 +448,7 @@ describe("CoFeed Branching", async () => {
         },
       });
 
-      assert(loadedTextFeed);
+      assertLoaded(loadedTextFeed);
 
       // Verify original is unchanged
       expect(loadedTextFeed.perAccount[me.$jazz.id]?.value?.toString()).toBe(
@@ -482,7 +481,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "subscribe-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       const spy = vi.fn();
       const unsubscribe = branch.$jazz.subscribe((feed, unsubscribe) => {
@@ -525,7 +524,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "ensure-loaded-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.push("jam");
       branch.$jazz.push("cheese");
@@ -559,7 +558,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "schema-subscribe-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       branch.$jazz.push("jam");
       branch.$jazz.push("cheese");
@@ -607,7 +606,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "nullable-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       // Edit the branch
       branch.$jazz.push("jam");
@@ -648,7 +647,7 @@ describe("CoFeed Branching", async () => {
         unstable_branch: { name: "nested-feed-branch" },
       });
 
-      assert(branch);
+      assertLoaded(branch);
 
       // Make changes to the branch
       const newTwiceNested = TwiceNestedStream.create(["bread"], {
@@ -661,24 +660,41 @@ describe("CoFeed Branching", async () => {
       branch.$jazz.push(newNested);
 
       // Verify the original is unchanged
-      expect(
-        originalFeed.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]
-          ?.value?.perAccount[me.$jazz.id]?.value,
-      ).toEqual("milk");
+      const myTopLevelStream = originalFeed.perAccount[me.$jazz.id];
+      assert(myTopLevelStream);
+      assertLoaded(myTopLevelStream.value);
+      const myNestedStream = myTopLevelStream.value.perAccount[me.$jazz.id];
+      assert(myNestedStream);
+      assertLoaded(myNestedStream.value);
+      expect(myNestedStream.value.perAccount[me.$jazz.id]?.value).toEqual(
+        "milk",
+      );
 
       // Verify the branch has the changes
+      const myBranchedTopLevelStream = branch.perAccount[me.$jazz.id];
+      assert(myBranchedTopLevelStream);
+      assertLoaded(myBranchedTopLevelStream.value);
+      const myBranchedNestedStream =
+        myBranchedTopLevelStream.value.perAccount[me.$jazz.id];
+      assert(myBranchedNestedStream);
+      assertLoaded(myBranchedNestedStream.value);
       expect(
-        branch.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
-          ?.perAccount[me.$jazz.id]?.value,
+        myBranchedNestedStream.value.perAccount[me.$jazz.id]?.value,
       ).toEqual("bread");
 
       // Merge the branch
       branch.$jazz.unstable_merge();
 
       // Verify the original now has the merged changes
+      const myOriginalTopLevelStream = originalFeed.perAccount[me.$jazz.id];
+      assert(myOriginalTopLevelStream);
+      assertLoaded(myOriginalTopLevelStream.value);
+      const myOriginalNestedStream =
+        myOriginalTopLevelStream.value.perAccount[me.$jazz.id];
+      assert(myOriginalNestedStream);
+      assertLoaded(myOriginalNestedStream.value);
       expect(
-        originalFeed.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]
-          ?.value?.perAccount[me.$jazz.id]?.value,
+        myOriginalNestedStream.value.perAccount[me.$jazz.id]?.value,
       ).toEqual("bread");
     });
   });

package/src/tools/tests/coFeed.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 { CoFeed, FileStream, Loaded } from "../internal.js";
+import { CoFeed, FileStream, Loaded, MaybeLoaded } from "../internal.js";
+import { assertLoaded } from "./utils.js";
 
 describe("CoFeed", () => {
   describe("init", () => {
@@ -39,7 +40,7 @@ describe("CoFeed", () => {
         Dog.create({ name: "Rex", breed: "Labrador" }),
       ]);
 
-      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
@@ -60,7 +61,7 @@ describe("CoFeed", () => {
         Dog.create({ name: "Rex", breed: "Labrador" }),
       ]);
 
-      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
@@ -89,7 +90,7 @@ describe("CoFeed", () => {
 
       const feed = DogFeed.create([dog, undefined]);
 
-      type ExpectedType = Loaded<typeof Dog> | undefined | null;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
@@ -103,7 +104,7 @@ describe("CoFeed", () => {
 
       const feed = NestedFeed.create([co.feed(z.string()).create(["milk"])]);
 
-      type ExpectedType = CoFeed<string> | undefined | null;
+      type ExpectedType = MaybeLoaded<CoFeed<string>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
@@ -144,17 +145,19 @@ describe("CoFeed", () => {
         resolve: true,
       });
 
-      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
       }
 
+      assertLoaded(loadedFeed);
       matches(loadedFeed?.perAccount[Account.getMe().$jazz.id]?.value);
 
       assert(loadedFeed);
       const dog = loadedFeed.perAccount[Account.getMe().$jazz.id]?.value;
       assert(dog);
+      assertLoaded(dog);
       expectTypeOf(dog.name).toEqualTypeOf<string>();
     });
 
@@ -171,16 +174,17 @@ describe("CoFeed", () => {
       ]);
 
       const loadedFeed = await DogFeed.load(feed.$jazz.id, {
-        resolve: { $each: { $onError: null } },
+        resolve: { $each: { $onError: "catch" } },
       });
 
-      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
       }
 
-      matches(loadedFeed?.perAccount[Account.getMe().$jazz.id]?.value);
+      assertLoaded(loadedFeed);
+      matches(loadedFeed.perAccount[Account.getMe().$jazz.id]?.value);
     });
 
     test("loading a nested feed with deep resolve", async () => {
@@ -202,20 +206,23 @@ describe("CoFeed", () => {
         },
       });
 
-      type ExpectedType = Loaded<typeof Dog> | null | undefined;
+      type ExpectedType = MaybeLoaded<Loaded<typeof Dog>> | undefined;
 
       function matches(value: ExpectedType) {
         return value;
       }
 
+      assertLoaded(loadedFeed);
       const nestedFeed =
         loadedFeed?.perAccount[Account.getMe().$jazz.id]?.value;
       assert(nestedFeed);
+      assertLoaded(nestedFeed);
       matches(nestedFeed.perAccount[Account.getMe().$jazz.id]?.value);
 
       assert(loadedFeed);
       const dog = nestedFeed.perAccount[Account.getMe().$jazz.id]?.value;
       assert(dog);
+      assertLoaded(dog);
       expectTypeOf(dog.name).toEqualTypeOf<string>();
     });
   });

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

@@ -17,11 +17,12 @@ import {
   z,
 } from "../index.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { assertLoaded, setupTwoNodes, waitFor } from "./utils.js";
 import {
   CoFeed,
-  CoFeedInstanceCoValuesNullable,
+  CoFeedInstanceCoValuesMaybeLoaded,
   ControlledAccount,
+  CoValueLoadingState,
   TypeSym,
 } from "../internal.js";
 
@@ -187,10 +188,13 @@ describe("CoFeed resolution", async () => {
     // TODO: fix this
     // expectTypeOf(stream[me.id]).not.toBeAny();
 
-    expect(
-      stream.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
-        ?.perAccount[me.$jazz.id]?.value,
-    ).toEqual("milk");
+    const myTopLevelStream = stream.perAccount[me.$jazz.id];
+    assert(myTopLevelStream);
+    assertLoaded(myTopLevelStream.value);
+    const myNestedStream = myTopLevelStream.value.perAccount[me.$jazz.id];
+    assert(myNestedStream);
+    assertLoaded(myNestedStream.value);
+    expect(myNestedStream.value.perAccount[me.$jazz.id]?.value).toEqual("milk");
   });
 
   test("Loading and availability", async () => {
@@ -202,7 +206,7 @@ describe("CoFeed resolution", async () => {
       loadAs: anotherAccount,
     });
 
-    assert(loadedStream);
+    assertLoaded(loadedStream);
 
     const myStream = loadedStream.perAccount[me.$jazz.id];
 
@@ -210,7 +214,7 @@ describe("CoFeed resolution", async () => {
 
     await waitFor(() => expect(myStream.value).toBeTruthy());
 
-    assert(myStream.value);
+    assertLoaded(myStream.value);
 
     const loadedNestedStreamByMe = myStream.value.perAccount[me.$jazz.id];
 
@@ -218,7 +222,7 @@ describe("CoFeed resolution", async () => {
 
     await waitFor(() => expect(loadedNestedStreamByMe.value).toBeTruthy());
 
-    assert(loadedNestedStreamByMe.value);
+    assertLoaded(loadedNestedStreamByMe.value);
 
     const loadedTwiceNestedStreamByMe =
       loadedNestedStreamByMe.value.perAccount[me.$jazz.id];
@@ -236,7 +240,9 @@ describe("CoFeed resolution", async () => {
 
     const anotherAccount = await createJazzTestAccount();
 
-    let result: CoFeedInstanceCoValuesNullable<co.Feed<co.Feed<z.z.ZodString>>>;
+    let result: CoFeedInstanceCoValuesMaybeLoaded<
+      co.Feed<co.Feed<z.z.ZodString>>
+    >;
 
     TestStream.subscribe(
       stream.$jazz.id,
@@ -249,10 +255,13 @@ describe("CoFeed resolution", async () => {
     await waitFor(() => expect(result).toBeDefined());
 
     await waitFor(() => {
-      expect(
-        result.perAccount[accountId]?.value?.perAccount[accountId]?.value
-          ?.perAccount[accountId]?.value,
-      ).toBe("milk");
+      const myTopLevelStream = result.perAccount[accountId];
+      assert(myTopLevelStream);
+      assertLoaded(myTopLevelStream.value);
+      const myNestedStream = myTopLevelStream.value.perAccount[accountId];
+      assert(myNestedStream);
+      assertLoaded(myNestedStream.value);
+      expect(myNestedStream.value.perAccount[accountId]?.value).toBe("milk");
     });
 
     // When assigning a new nested stream, we get an update
@@ -267,20 +276,26 @@ describe("CoFeed resolution", async () => {
     stream.$jazz.push(newNested);
 
     await waitFor(() => {
-      expect(
-        result.perAccount[accountId]?.value?.perAccount[accountId]?.value
-          ?.perAccount[accountId]?.value,
-      ).toBe("butter");
+      const myTopLevelStream = result.perAccount[accountId];
+      assert(myTopLevelStream);
+      assertLoaded(myTopLevelStream.value);
+      const myNestedStream = myTopLevelStream.value.perAccount[accountId];
+      assert(myNestedStream);
+      assertLoaded(myNestedStream.value);
+      expect(myNestedStream.value.perAccount[accountId]?.value).toBe("butter");
     });
 
     // we get updates when the new nested stream changes
     newTwiceNested.$jazz.push("jam");
 
     await waitFor(() => {
-      expect(
-        result.perAccount[accountId]?.value?.perAccount[accountId]?.value
-          ?.perAccount[accountId]?.value,
-      ).toBe("jam");
+      const myTopLevelStream = result.perAccount[accountId];
+      assert(myTopLevelStream);
+      assertLoaded(myTopLevelStream.value);
+      const myNestedStream = myTopLevelStream.value.perAccount[accountId];
+      assert(myNestedStream);
+      assertLoaded(myNestedStream.value);
+      expect(myNestedStream.value.perAccount[accountId]?.value).toBe("jam");
     });
   });
 
@@ -299,9 +314,13 @@ describe("CoFeed resolution", async () => {
         ?.perAccount[me.$jazz.id]?.value,
     ).toBe("milk");
 
-    stream.perAccount[me.$jazz.id]!.value!.perAccount[
-      me.$jazz.id
-    ]!.value!.$jazz.push("bread");
+    const myTopLevelStream = stream.perAccount[me.$jazz.id];
+    assert(myTopLevelStream);
+    assertLoaded(myTopLevelStream.value);
+    const myNestedStream = myTopLevelStream.value.perAccount[me.$jazz.id];
+    assert(myNestedStream);
+    assertLoaded(myNestedStream.value);
+    myNestedStream.value.$jazz.push("bread");
 
     const update2 = (await queue.next()).value;
     expect(
@@ -417,7 +436,8 @@ describe("FileStream loading & Subscription", async () => {
       loadAs: anotherAccount,
     });
 
-    expect(loadedStream?.getChunks()).toEqual({
+    assertLoaded(loadedStream);
+    expect(loadedStream.getChunks()).toEqual({
       mimeType: "text/plain",
       chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
       finished: true,
@@ -557,6 +577,7 @@ describe("FileStream.load", async () => {
 
     const blob = await promise;
 
+    assertLoaded(blob);
     // The promise resolves only when the stream is ended
     // so we get a blob with all the chunks
     expect(blob?.getChunks()?.finished).toBe(true);
@@ -575,6 +596,7 @@ describe("FileStream.load", async () => {
 
     stream.push(new Uint8Array([2]));
 
+    assertLoaded(blob);
     // The promise resolves before the stream is ended
     // so we get a blob only with the first chunk
     expect(blob?.getChunks({ allowUnfinished: true })?.finished).toBe(false);
@@ -769,7 +791,7 @@ describe("FileStream large file loading", async () => {
       allowUnfinished: true,
     });
 
-    assert(loadedStream);
+    assertLoaded(loadedStream);
 
     const loadedChunks = loadedStream.getChunks({ allowUnfinished: true });
     expect(loadedChunks).not.toBeNull();
@@ -816,7 +838,7 @@ describe("FileStream large file loading", async () => {
       allowUnfinished: false,
     });
 
-    assert(loadedStream);
+    assertLoaded(loadedStream);
 
     const loadedChunks = loadedStream.getChunks();
     expect(loadedChunks).not.toBeNull();
@@ -844,7 +866,7 @@ describe("waitForSync", async () => {
 
     const loadedStream = await serverNode.load(stream.$jazz.raw.id);
 
-    expect(loadedStream).not.toBe("unavailable");
+    expect(loadedStream).not.toBe(CoValueLoadingState.UNAVAILABLE);
   });
 
   test("FileStream: should resolve when the value is uploaded", async () => {
@@ -863,7 +885,7 @@ describe("waitForSync", async () => {
 
     const loadedStream = await serverNode.load(stream.$jazz.raw.id);
 
-    expect(loadedStream).not.toBe("unavailable");
+    expect(loadedStream).not.toBe(CoValueLoadingState.UNAVAILABLE);
   });
 
   test("should rely on the current active account if no account is provided", async () => {