jazz-tools 0.18.38 → 0.19.0

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

@@ -17,7 +17,9 @@ import {
   TypeSym,
   activeAccountContext,
   coValueClassFromCoValueClassOrSchema,
+  CoValueLoadingState,
   exportCoValue,
+  MaybeLoaded,
 } from "../internal.js";
 import {
   createJazzTestAccount,
@@ -26,7 +28,7 @@ import {
   runWithoutActiveAccount,
   setupJazzTestSync,
 } from "../testing.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { assertLoaded, setupTwoNodes, waitFor } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -501,7 +503,7 @@ describe("CoMap", async () => {
       });
 
       expect(loadedPersonA).not.toBeNull();
-      assert(loadedPersonA);
+      assertLoaded(loadedPersonA);
 
       const personB = Person.create({
         name: "Jane",
@@ -848,9 +850,11 @@ describe("CoMap", async () => {
         loadAs: clientAccount,
       });
 
-      assert(loadedPerson);
+      assertLoaded(loadedPerson);
       expect(loadedPerson.$jazz.has("name")).toBe(true);
-      expect(loadedPerson.name).toBeNull();
+      expect(loadedPerson.name.$jazz.loadingState).toBe(
+        CoValueLoadingState.LOADING,
+      );
     });
 
     test("should return true even if the viewer doesn't have access to the referenced CoValue", async () => {
@@ -872,9 +876,11 @@ describe("CoMap", async () => {
         loadAs: userB,
       });
 
-      assert(loadedPerson);
+      assertLoaded(loadedPerson);
       expect(loadedPerson.$jazz.has("name")).toBe(true);
-      expect(loadedPerson.name).toBeNull();
+      expect(loadedPerson.name.$jazz.loadingState).toBe(
+        CoValueLoadingState.LOADING,
+      );
     });
   });
 
@@ -939,7 +945,7 @@ describe("CoMap resolution", async () => {
       },
     });
 
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
     expect(loadedPerson.dog.name).toEqual("Rex");
   });
 
@@ -963,8 +969,9 @@ describe("CoMap resolution", async () => {
 
     const loadedPerson = await Person.load(person.$jazz.id);
 
-    assert(loadedPerson);
-    expect(loadedPerson.dog?.name).toEqual("Rex");
+    assertLoaded(loadedPerson);
+    assertLoaded(loadedPerson.dog);
+    expect(loadedPerson.dog.name).toEqual("Rex");
   });
 
   test("loading a remotely available map with deep resolve", async () => {
@@ -1000,7 +1007,7 @@ describe("CoMap resolution", async () => {
       loadAs: userB,
     });
 
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
     expect(loadedPerson.dog.name).toEqual("Rex");
   });
 
@@ -1033,10 +1040,11 @@ describe("CoMap resolution", async () => {
       loadAs: userB,
     });
 
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
 
     await waitFor(() => {
-      expect(loadedPerson.dog?.name).toEqual("Rex");
+      assertLoaded(loadedPerson.dog);
+      expect(loadedPerson.dog.name).toEqual("Rex");
     });
   });
 
@@ -1084,7 +1092,9 @@ describe("CoMap resolution", async () => {
       skipRetry: true,
     });
 
-    expect(loadedPerson).toBeNull();
+    expect(loadedPerson.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAVAILABLE,
+    );
   });
 
   test("loading a remotely available map with skipRetry set to false", async () => {
@@ -1145,10 +1155,11 @@ describe("CoMap resolution", async () => {
     const loadedPerson = await promise;
 
     expect(resolved).toBe(true);
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
 
     await waitFor(() => {
-      expect(loadedPerson.dog?.name).toEqual("Rex");
+      assertLoaded(loadedPerson.dog);
+      expect(loadedPerson.dog.name).toEqual("Rex");
     });
   });
 
@@ -1205,13 +1216,13 @@ describe("CoMap resolution", async () => {
       loadAs: userB,
     });
 
-    assert(loadedPerson);
+    assertLoaded(loadedPerson);
 
     expect(loadedPerson.$jazz.refs.dog.id).toBe(person.dog.$jazz.id);
 
     const dog = await loadedPerson.$jazz.refs.dog.load();
 
-    assert(dog);
+    assertLoaded(dog);
 
     expect(dog.name).toEqual("Rex");
   });
@@ -1293,13 +1304,17 @@ describe("CoMap resolution", async () => {
 
     expect(spy).toHaveBeenCalledTimes(1);
 
-    expect(updates[0]?.dog?.name).toEqual("Rex");
+    assert(updates[0]);
+    assertLoaded(updates[0].dog);
+    expect(updates[0].dog.name).toEqual("Rex");
 
-    person.dog!.$jazz.set("name", "Fido");
+    person.dog.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
-    expect(updates[1]?.dog?.name).toEqual("Fido");
+    assert(updates[1]);
+    assertLoaded(updates[1].dog);
+    expect(updates[1].dog.name).toEqual("Fido");
 
     expect(spy).toHaveBeenCalledTimes(2);
   });
@@ -1338,15 +1353,19 @@ describe("CoMap resolution", async () => {
     expect(spy).toHaveBeenCalled();
     expect(spy).toHaveBeenCalledTimes(1);
 
-    expect(updates[0]?.dog?.name).toEqual("Rex");
+    assert(updates[0]);
+    assertLoaded(updates[0].dog);
+    expect(updates[0].dog.name).toEqual("Rex");
 
     expect(spy).toHaveBeenCalledTimes(1);
 
-    person.dog!.$jazz.set("name", "Fido");
+    person.dog.$jazz.set("name", "Fido");
 
     expect(spy).toHaveBeenCalledTimes(2);
 
-    expect(updates[1]?.dog?.name).toEqual("Fido");
+    assert(updates[1]);
+    assertLoaded(updates[1].dog);
+    expect(updates[1].dog.name).toEqual("Fido");
 
     expect(spy).toHaveBeenCalledTimes(2);
   });
@@ -1452,14 +1471,18 @@ describe("CoMap resolution", async () => {
     expect(spy).toHaveBeenCalledTimes(1);
 
     await waitFor(() => {
-      expect(updates[0]?.dog?.name).toEqual("Rex");
+      assert(updates[0]);
+      assertLoaded(updates[0].dog);
+      expect(updates[0].dog.name).toEqual("Rex");
     });
 
-    person.dog!.$jazz.set("name", "Fido");
+    person.dog.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(3));
 
-    expect(updates[1]?.dog?.name).toEqual("Fido");
+    assert(updates[1]);
+    assertLoaded(updates[1].dog);
+    expect(updates[1].dog.name).toEqual("Fido");
 
     expect(spy).toHaveBeenCalledTimes(3);
   });
@@ -1833,7 +1856,7 @@ describe("CoMap Typescript validation", async () => {
 
     const loadedMap = await serverNode.load(map.$jazz.raw.id);
 
-    expect(loadedMap).not.toBe("unavailable");
+    expect(loadedMap).not.toBe(CoValueLoadingState.UNAVAILABLE);
   });
 
   test("complex discriminated union", () => {
@@ -2022,9 +2045,10 @@ describe("CoMap migration", () => {
 
     const loadedPerson = await Person.load(person.$jazz.id);
 
-    expect(loadedPerson?.name).toEqual("Bob");
-    expect(loadedPerson?.age).toEqual(20);
-    expect(loadedPerson?.version).toEqual(2);
+    assertLoaded(loadedPerson);
+    expect(loadedPerson.name).toEqual("Bob");
+    expect(loadedPerson.age).toEqual(20);
+    expect(loadedPerson.version).toEqual(2);
   });
 
   test("should handle group updates", async () => {
@@ -2051,8 +2075,9 @@ describe("CoMap migration", () => {
 
     const loadedPerson = await Person.load(person.$jazz.id);
 
-    expect(loadedPerson?.name).toEqual("Bob");
-    expect(loadedPerson?.version).toEqual(2);
+    assertLoaded(loadedPerson);
+    expect(loadedPerson.name).toEqual("Bob");
+    expect(loadedPerson.version).toEqual(2);
 
     const anotherAccount = await createJazzTestAccount();
 
@@ -2060,7 +2085,8 @@ describe("CoMap migration", () => {
       loadAs: anotherAccount,
     });
 
-    expect(loadedPersonFromAnotherAccount?.name).toEqual("Bob");
+    assertLoaded(loadedPersonFromAnotherAccount);
+    expect(loadedPersonFromAnotherAccount.name).toEqual("Bob");
   });
 
   test("should throw an error if a migration is async", async () => {
@@ -2146,11 +2172,12 @@ describe("CoMap migration", () => {
     });
 
     // Migration should run on both the person and their friend
-    expect(loaded?.name).toEqual("Bob");
-    expect(loaded?.age).toEqual(20);
-    expect(loaded?.version).toEqual(2);
-    expect(loaded?.friend?.name).toEqual("Charlie");
-    expect(loaded?.friend?.version).toEqual(2);
+    assertLoaded(loaded);
+    expect(loaded.name).toEqual("Bob");
+    expect(loaded.age).toEqual(20);
+    expect(loaded.version).toEqual(2);
+    expect(loaded.friend?.name).toEqual("Charlie");
+    expect(loaded.friend?.version).toEqual(2);
   });
 
   test("should wait for the full streaming before running the migration", async () => {
@@ -2527,7 +2554,7 @@ describe("Updating a nested reference", () => {
       },
     });
 
-    assert(loadedGame);
+    assertLoaded(loadedGame);
 
     // Create a play selection
     const playSelection = PlaySelection.create({ value: "rock", group }, group);
@@ -2595,7 +2622,7 @@ describe("Updating a nested reference", () => {
       },
     });
 
-    assert(loadedGame);
+    assertLoaded(loadedGame);
 
     // Create a play selection
     const playSelection = PlaySelection.create({ value: "scissors" });

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

@@ -1,11 +1,13 @@
 import { cojsonInternals } from "cojson";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import {
+  assertLoaded,
   setupJazzTestSync,
   createJazzTestAccount,
   runWithoutActiveAccount,
 } from "../testing";
 import {
+  CoValueLoadingState,
   Group,
   co,
   activeAccountContext,
@@ -104,7 +106,8 @@ describe("Creating and finding unique CoMaps", async () => {
       },
       owner: group,
     });
-    expect(alice?.name).toEqual("Alice");
+    assertLoaded(alice);
+    expect(alice.name).toEqual("Alice");
   });
 
   test("manual upserting pattern", async () => {
@@ -128,7 +131,7 @@ describe("Creating and finding unique CoMaps", async () => {
       { identifier: sourceData.identifier },
       workspace.$jazz.id,
     );
-    if (!activeEvent) {
+    if (!activeEvent.$isLoaded) {
       activeEvent = Event.create(
         {
           title: sourceData.title,
@@ -215,7 +218,7 @@ describe("Creating and finding unique CoMaps", async () => {
     const workspaceOnAlice = await Group.load(workspace.$jazz.id, {
       loadAs: alice,
     });
-    assert(workspaceOnAlice);
+    assertLoaded(workspaceOnAlice);
 
     const eventOnAlice = await Event.upsertUnique({
       value: {
@@ -226,7 +229,10 @@ describe("Creating and finding unique CoMaps", async () => {
       unique: sourceData.identifier,
       owner: workspaceOnAlice,
     });
-    expect(eventOnAlice).toBeNull();
+    expect(eventOnAlice.$isLoaded).toBe(false);
+    expect(eventOnAlice.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
   });
 
   test("upserting without an active account", async () => {
@@ -264,7 +270,7 @@ describe("Creating and finding unique CoMaps", async () => {
       external_id: sourceData._id,
     });
 
-    assert(activeEvent);
+    assertLoaded(activeEvent);
 
     expect(activeEvent.$jazz.owner).toEqual(account);
   });
@@ -350,8 +356,7 @@ describe("Creating and finding unique CoMaps", async () => {
         },
       },
     });
-    assert(myOrg);
-    expect(myOrg).not.toBeNull();
+    assertLoaded(myOrg);
     expect(myOrg.name).toEqual("My organisation");
     expect(myOrg.projects.length).toBe(1);
     expect(myOrg.projects[0]).toMatchObject({
@@ -375,8 +380,7 @@ describe("Creating and finding unique CoMaps", async () => {
       unique: { unique: "First project" },
       owner: workspace,
     });
-    assert(initialProject);
-    expect(initialProject).not.toBeNull();
+    assertLoaded(initialProject);
     expect(initialProject.name).toEqual("My project");
 
     const myOrg = await Organisation.upsertUnique({
@@ -392,8 +396,7 @@ describe("Creating and finding unique CoMaps", async () => {
         },
       },
     });
-    assert(myOrg);
-    expect(myOrg).not.toBeNull();
+    assertLoaded(myOrg);
     expect(myOrg.name).toEqual("My organisation");
     expect(myOrg.projects.length).toBe(1);
     expect(myOrg.projects.at(0)?.name).toEqual("My project");
@@ -406,8 +409,7 @@ describe("Creating and finding unique CoMaps", async () => {
       owner: workspace,
     });
 
-    assert(updatedProject);
-    expect(updatedProject).not.toBeNull();
+    assertLoaded(updatedProject);
     expect(updatedProject).toEqual(initialProject);
     expect(updatedProject.name).toEqual("My updated project");
     expect(myOrg.projects.length).toBe(1);
@@ -432,8 +434,7 @@ describe("Creating and finding unique CoMaps", async () => {
       unique: { unique: "First project" },
       owner: publicAccess,
     });
-    assert(initialProject);
-    expect(initialProject).not.toBeNull();
+    assertLoaded(initialProject);
     expect(initialProject.name).toEqual("My project");
 
     const fullProjectList = co
@@ -449,12 +450,12 @@ describe("Creating and finding unique CoMaps", async () => {
       .load(fullProjectList.$jazz.id, {
         loadAs: account,
       });
-    assert(shallowProjectList);
+    assertLoaded(shallowProjectList);
 
     const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
       loadAs: account,
     });
-    assert(publicAccessAsNewAccount);
+    assertLoaded(publicAccessAsNewAccount);
 
     const updatedOrg = await Organisation.upsertUnique({
       value: {
@@ -470,7 +471,7 @@ describe("Creating and finding unique CoMaps", async () => {
       },
     });
 
-    assert(updatedOrg);
+    assertLoaded(updatedOrg);
 
     expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
     expect(updatedOrg.projects.length).toBe(1);
@@ -495,7 +496,7 @@ describe("Creating and finding unique CoMaps", async () => {
       unique: { unique: "First project" },
       owner: publicAccess,
     });
-    assert(initialProject);
+    assertLoaded(initialProject);
 
     const myOrg = await Organisation.upsertUnique({
       value: {
@@ -510,7 +511,7 @@ describe("Creating and finding unique CoMaps", async () => {
         },
       },
     });
-    assert(myOrg);
+    assertLoaded(myOrg);
 
     const fullProjectList = co
       .list(Project)
@@ -525,12 +526,12 @@ describe("Creating and finding unique CoMaps", async () => {
       .load(fullProjectList.$jazz.id, {
         loadAs: account,
       });
-    assert(shallowProjectList);
+    assertLoaded(shallowProjectList);
 
     const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
       loadAs: account,
     });
-    assert(publicAccessAsNewAccount);
+    assertLoaded(publicAccessAsNewAccount);
 
     const updatedOrg = await Organisation.upsertUnique({
       value: {
@@ -546,7 +547,7 @@ describe("Creating and finding unique CoMaps", async () => {
       },
     });
 
-    assert(updatedOrg);
+    assertLoaded(updatedOrg);
 
     expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
     expect(updatedOrg.projects.length).toBe(1);
@@ -572,7 +573,7 @@ describe("Creating and finding unique CoMaps", async () => {
     await Promise.all(promises);
 
     const result = await Project.loadUnique("concurrent", owner.$jazz.id);
-    assert(result);
+    assertLoaded(result);
 
     expect(result.name).toBe(`Project 2`);
   });

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

@@ -8,7 +8,7 @@ import {
   co,
 } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { assertLoaded, setupTwoNodes, waitFor } from "./utils.js";
 
 let me: ControlledAccount;
 
@@ -508,7 +508,7 @@ describe("CoVector loading & availability", async () => {
       loadAs: alice,
     });
 
-    assert(loadedVector);
+    assertLoaded(loadedVector);
     expect(loadedVector.length).toBe(3);
     expect(loadedVector[0]).toBe(9);
     expect(loadedVector[1]).toBe(8);
@@ -541,7 +541,7 @@ describe("CoVector loading & availability", async () => {
       loadAs: alice,
     });
 
-    assert(loadedVector);
+    assertLoaded(loadedVector);
     expect(loadedVector).toBeInstanceOf(CoVector);
     expect(loadedVector.length).toBe(elementsForKb(kb));
     expect(loadedVector.every((item) => item === 0.5)).toBe(true);
@@ -696,14 +696,16 @@ describe("CoVector in subscription", async () => {
 
         expect(updatesCallback).toHaveBeenCalledTimes(1);
 
-        expect(updates[0]?.[0]?.content).toEqual(
-          "Call GET to retrieve document",
-        );
-        expect(updates[0]?.[1]?.content).toEqual(
+        assert(updates[0]?.[0]);
+        assertLoaded(updates[0][0]);
+        assert(updates[0]?.[1]);
+        assertLoaded(updates[0][1]);
+        expect(updates[0][0].content).toEqual("Call GET to retrieve document");
+        expect(updates[0][1].content).toEqual(
           "Call POST to create a new document",
         );
-        expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
-        expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+        expect(updates[0][0].embedding?.toString()).toBe("1,2,3");
+        expect(updates[0][1].embedding?.toString()).toBe("4,5,6");
 
         // Update the second document's embedding
         docs[1]!.$jazz.set(
@@ -713,8 +715,12 @@ describe("CoVector in subscription", async () => {
 
         await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(2));
 
-        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
-        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+        assert(updates[1]?.[0]);
+        assertLoaded(updates[1][0]);
+        assert(updates[1]?.[1]);
+        assertLoaded(updates[1][1]);
+        expect(updates[1][0].embedding?.toString()).toBe("1,2,3");
+        expect(updates[1][1].embedding?.toString()).toBe("7,8,9");
 
         expect(updatesCallback).toHaveBeenCalledTimes(2);
       });
@@ -838,8 +844,12 @@ describe("CoVector in subscription", async () => {
         await waitFor(() => expect(updatesCallback).toHaveBeenCalled());
 
         await waitFor(() => {
-          expect(updates[0]?.[0]?.embedding?.toString()).toBe("1,2,3");
-          expect(updates[0]?.[1]?.embedding?.toString()).toBe("4,5,6");
+          assert(updates[0]?.[0]);
+          assertLoaded(updates[0][0]);
+          assert(updates[0]?.[1]);
+          assertLoaded(updates[0][1]);
+          expect(updates[0][0].embedding?.toString()).toBe("1,2,3");
+          expect(updates[0][1].embedding?.toString()).toBe("4,5,6");
         });
 
         // Update the second document's embedding
@@ -850,8 +860,12 @@ describe("CoVector in subscription", async () => {
 
         await waitFor(() => expect(updatesCallback).toHaveBeenCalledTimes(7));
 
-        expect(updates[1]?.[0]?.embedding?.toString()).toBe("1,2,3");
-        expect(updates[1]?.[1]?.embedding?.toString()).toBe("7,8,9");
+        assert(updates[1]?.[0]);
+        assertLoaded(updates[1][0]);
+        assert(updates[1]?.[1]);
+        assertLoaded(updates[1][1]);
+        expect(updates[1][0].embedding?.toString()).toBe("1,2,3");
+        expect(updates[1][1].embedding?.toString()).toBe("7,8,9");
 
         expect(updatesCallback).toHaveBeenCalledTimes(7);
       });

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

@@ -23,7 +23,7 @@ import {
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing";
-import { loadCoValueOrFail } from "./utils";
+import { assertLoaded, loadCoValueOrFail } from "./utils";
 const Crypto = await WasmCrypto.create();
 
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
@@ -190,7 +190,8 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeDefined();
-      expect(context.account.profile?.name).toBe("New User");
+      assertLoaded(context.account.profile);
+      expect(context.account.profile.name).toBe("New User");
     });
 
     test("uses initial agent secret when provided", async () => {
@@ -322,7 +323,8 @@ describe("createContext methods", () => {
         sessionProvider: randomSessionProvider,
       });
 
-      expect(context.account.profile?.name).toBe("Custom User");
+      assertLoaded(context.account.profile);
+      expect(context.account.profile.name).toBe("Custom User");
     });
 
     test("uses initial agent secret when provided", async () => {