jazz-tools 0.18.38 → 0.19.0

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

@@ -7,6 +7,7 @@ import {
   createJazzTestGuest,
   setupJazzTestSync,
 } from "../testing.js";
+import { assertLoaded } from "./utils.js";
 
 cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 10;
 
@@ -291,9 +292,9 @@ describe("importContentPieces", () => {
 
     // Verify bob can now access the person
     const importedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-    expect(importedPerson).not.toBeNull();
-    expect(importedPerson?.name).toBe("John");
-    expect(importedPerson?.age).toBe(30);
+    assertLoaded(importedPerson);
+    expect(importedPerson.name).toBe("John");
+    expect(importedPerson.age).toBe(30);
   });
 
   test("imports content pieces with nested references", async () => {
@@ -339,11 +340,11 @@ describe("importContentPieces", () => {
       loadAs: bob,
     });
 
-    expect(importedPerson).not.toBeNull();
-    expect(importedPerson?.name).toBe("John");
-    expect(importedPerson?.address).not.toBeNull();
-    expect(importedPerson?.address.street).toBe("123 Main St");
-    expect(importedPerson?.address.city).toBe("New York");
+    assertLoaded(importedPerson);
+    expect(importedPerson.name).toBe("John");
+    expect(importedPerson.address).not.toBeNull();
+    expect(importedPerson.address.street).toBe("123 Main St");
+    expect(importedPerson.address.city).toBe("New York");
   });
 
   test("imports content pieces to anonymous agent", async () => {
@@ -376,8 +377,8 @@ describe("importContentPieces", () => {
     const importedPerson = await Person.load(person.$jazz.id, {
       loadAs: guest,
     });
-    expect(importedPerson).not.toBeNull();
-    expect(importedPerson?.name).toBe("John");
+    assertLoaded(importedPerson);
+    expect(importedPerson.name).toBe("John");
   });
 
   test("imports content pieces without specifying loadAs (uses current account)", async () => {
@@ -410,8 +411,8 @@ describe("importContentPieces", () => {
 
     // Verify bob can access the person
     const importedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-    expect(importedPerson).not.toBeNull();
-    expect(importedPerson?.name).toBe("John");
+    assertLoaded(importedPerson);
+    expect(importedPerson.name).toBe("John");
   });
 
   test("handles empty content pieces array", async () => {
@@ -452,8 +453,8 @@ describe("importContentPieces", () => {
 
     // Should still work correctly
     const importedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-    expect(importedPerson).not.toBeNull();
-    expect(importedPerson?.name).toBe("John");
+    assertLoaded(importedPerson);
+    expect(importedPerson.name).toBe("John");
   });
 
   test("imports content pieces with complex nested structure", async () => {
@@ -534,7 +535,7 @@ describe("importContentPieces", () => {
       loadAs: bob,
     });
 
-    expect(importedBlog).not.toBeNull();
+    assertLoaded(importedBlog);
     expect(importedBlog?.name).toBe("My Blog");
     expect(importedBlog?.posts.length).toBe(1);
     expect(importedBlog?.posts[0]?.title).toBe("My First Post");

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

@@ -1,9 +1,21 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { CoMap, Group, z } from "../exports.js";
-import { Account, Loaded, Ref, co } from "../internal.js";
+import {
+  Account,
+  Loaded,
+  MaybeLoaded,
+  Ref,
+  co,
+  CoValueLoadingState,
+} from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { loadCoValueOrFail, setupTwoNodes, waitFor } from "./utils.js";
+import {
+  assertLoaded,
+  loadCoValueOrFail,
+  setupTwoNodes,
+  waitFor,
+} from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -31,9 +43,9 @@ describe("Custom accounts and groups", async () => {
       .withMigration((account, creationProps?: { name: string }) => {
         // making sure that the inferred type of account.root & account.profile considers the root/profile not being loaded
         type R = typeof account.root;
-        const _r: R = {} as Loaded<typeof Root> | null;
+        const _r: R = {} as MaybeLoaded<Loaded<typeof Root>>;
         type P = typeof account.profile;
-        const _p: P = {} as Loaded<typeof CustomProfile> | null;
+        const _p: P = {} as MaybeLoaded<Loaded<typeof CustomProfile>>;
         if (creationProps) {
           const profileGroup = Group.create({ owner: account });
           profileGroup.addMember("everyone", "reader");
@@ -65,8 +77,10 @@ describe("Custom accounts and groups", async () => {
     const meAsMember = group.members.find(
       (member) => member.id === me.$jazz.id,
     );
-    assert(meAsMember?.account);
-    expect((meAsMember?.account).profile?.name).toBe("Hermes Puggington");
+    const memberAccount = meAsMember?.account;
+    assert(memberAccount);
+    assertLoaded(memberAccount.profile);
+    expect(memberAccount.profile.name).toBe("Hermes Puggington");
   });
 });
 
@@ -97,7 +111,8 @@ describe("Group inheritance", () => {
     const mapAsReader = await TestMap.load(mapInChild.$jazz.id, {
       loadAs: reader,
     });
-    expect(mapAsReader?.title).toBe("In Child");
+    assertLoaded(mapAsReader);
+    expect(mapAsReader.title).toBe("In Child");
 
     await parentGroup.removeMember(reader);
 
@@ -107,7 +122,9 @@ describe("Group inheritance", () => {
       const mapAsReaderAfterUpdate = await TestMap.load(mapInChild.$jazz.id, {
         loadAs: reader,
       });
-      expect(mapAsReaderAfterUpdate).toBe(null);
+      expect(mapAsReaderAfterUpdate.$jazz.loadingState).toBe(
+        CoValueLoadingState.UNAUTHORIZED,
+      );
     });
   });
 
@@ -138,7 +155,8 @@ describe("Group inheritance", () => {
     const mapAsReader = await TestMap.load(mapInGrandChild.$jazz.id, {
       loadAs: reader,
     });
-    expect(mapAsReader?.title).toBe("In Grand Child");
+    assertLoaded(mapAsReader);
+    expect(mapAsReader.title).toBe("In Grand Child");
 
     await grandParentGroup.removeMember(reader);
 
@@ -152,7 +170,9 @@ describe("Group inheritance", () => {
         loadAs: reader,
       },
     );
-    expect(mapAsReaderAfterUpdate).toBe(null);
+    expect(mapAsReaderAfterUpdate.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
   });
 
   test("Group.getParentGroups should return the parent groups", async () => {
@@ -196,7 +216,7 @@ describe("Group inheritance", () => {
 
     const loadedGroup = await serverNode.load(group.$jazz.raw.id);
 
-    expect(loadedGroup).not.toBe("unavailable");
+    expect(loadedGroup).not.toBe(CoValueLoadingState.UNAVAILABLE);
   });
 
   test("everyone is valid only for reader, writer and writeOnly roles", () => {
@@ -275,8 +295,8 @@ describe("Group inheritance", () => {
     const loadedAlice = await Account.load(alice.$jazz.id);
     const loadedBob = await Account.load(bob.$jazz.id);
 
-    assert(loadedBob);
-    assert(loadedAlice);
+    assertLoaded(loadedBob);
+    assertLoaded(loadedAlice);
 
     const parentGroup = Group.create();
     // `parentGroup` has `alice` as a writer
@@ -331,9 +351,10 @@ describe("Group inheritance", () => {
       const task = board.columns[0]![0]!;
 
       const boardAsWriter = await Board.load(board.$jazz.id, { loadAs: me });
-      expect(boardAsWriter?.title).toEqual("My board");
+      assertLoaded(boardAsWriter);
+      expect(boardAsWriter.title).toEqual("My board");
       const taskAsWriter = await Task.load(task.$jazz.id, { loadAs: me });
-      expect(taskAsWriter?.toString()).toEqual("Task 1.1");
+      expect(taskAsWriter.toString()).toEqual("Task 1.1");
     });
 
     test("nested CoValues inherit permissions from the referencing CoValue", async () => {
@@ -351,7 +372,9 @@ describe("Group inheritance", () => {
       const boardAsReader = await Board.load(board.$jazz.id, {
         loadAs: reader,
       });
-      expect(boardAsReader).toBeNull();
+      expect(boardAsReader.$jazz.loadingState).toBe(
+        CoValueLoadingState.UNAUTHORIZED,
+      );
     });
   });
 });

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

@@ -14,6 +14,7 @@ import {
 } from "../testing";
 import { cojsonInternals, LocalNode } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { assertLoaded } from "./utils";
 
 const Message = co.map({
   text: z.string(),
@@ -163,7 +164,8 @@ describe("Inbox", () => {
     const resultId = await inboxSender.sendMessage(message);
 
     const result = await Message.load(resultId, { loadAs: receiver });
-    expect(result?.text).toBe("Responded from the inbox");
+    assertLoaded(result);
+    expect(result.text).toBe("Responded from the inbox");
 
     unsubscribe();
   });

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

@@ -1,13 +1,14 @@
-import { waitFor } from "@testing-library/dom";
 import { cojsonInternals, emptyKnownState } from "cojson";
 import { assert, beforeEach, expect, test } from "vitest";
 import { Account, Group, co, exportCoValue, z } from "../exports.js";
+import { CoValueLoadingState } from "../internal.js";
 import {
   createJazzTestAccount,
   disableJazzTestSync,
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing.js";
+import { assertLoaded, waitFor } from "./utils.js";
 
 cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 10;
 
@@ -30,17 +31,17 @@ test("load a value", async () => {
   const alice = await createJazzTestAccount();
 
   const john = await Person.load(map.$jazz.id, { loadAs: alice });
-  expect(john).not.toBeNull();
+  assertLoaded(john);
   expect(john?.name).toBe("John");
 });
 
-test("return null if id is invalid", async () => {
+test("return 'unavailable' if id is invalid", async () => {
   const Person = co.map({
     name: z.string(),
   });
 
   const john = await Person.load("test");
-  expect(john).toBeNull();
+  expect(john.$jazz.loadingState).toBe(CoValueLoadingState.UNAVAILABLE);
 });
 
 test("load a missing optional value (co.optional)", async () => {
@@ -64,8 +65,7 @@ test("load a missing optional value (co.optional)", async () => {
     resolve: { dog: true },
   });
 
-  assert(john);
-
+  assertLoaded(john);
   expect(john.name).toBe("John");
   expect(john.dog).toBeUndefined();
 });
@@ -91,8 +91,7 @@ test("load a missing optional value (Schema.optional)", async () => {
     resolve: { dog: true },
   });
 
-  assert(john);
-
+  assertLoaded(john);
   expect(john.name).toBe("John");
   expect(john.dog).toBeUndefined();
 });
@@ -124,8 +123,7 @@ test("load a missing optional value (optional discrminatedUnion)", async () => {
     resolve: { pet: true },
   });
 
-  assert(john);
-
+  assertLoaded(john);
   expect(john.name).toBe("John");
   expect(john.pet).toBeUndefined();
 });
@@ -160,11 +158,11 @@ test("retry an unavailable value", async () => {
   );
 
   const john = await promise;
-  expect(john).not.toBeNull();
-  expect(john?.name).toBe("John");
+  assertLoaded(john);
+  expect(john.name).toBe("John");
 });
 
-test("returns null if the value is unavailable after retries", async () => {
+test("returns 'unavailable' if the value is unavailable after retries", async () => {
   const Person = co.map({
     name: z.string(),
   });
@@ -186,7 +184,7 @@ test("returns null if the value is unavailable after retries", async () => {
 
   const john = await Person.load(map.$jazz.id, { loadAs: alice });
 
-  expect(john).toBeNull();
+  expect(john.$jazz.loadingState).toBe(CoValueLoadingState.UNAVAILABLE);
 });
 
 test("load works even when the coValue access is granted after the creation", async () => {
@@ -204,8 +202,8 @@ test("load works even when the coValue access is granted after the creation", as
 
   const mapOnBob = await Person.load(map.$jazz.id, { loadAs: bob });
 
-  expect(mapOnBob).not.toBeNull();
-  expect(mapOnBob?.name).toBe("John");
+  assertLoaded(mapOnBob);
+  expect(mapOnBob.name).toBe("John");
 });
 
 test("load a large coValue", async () => {
@@ -259,8 +257,7 @@ test("load a large coValue", async () => {
     },
   });
 
-  assert(loadedDataset);
-
+  assertLoaded(loadedDataset);
   expect(loadedDataset.metadata.name).toBe("Large Dataset");
   expect(loadedDataset.metadata.description).toBe(
     "A dataset with many entries for testing large coValue loading",
@@ -329,9 +326,8 @@ test("should wait for the full streaming of the group", async () => {
 
   // Load the value and expect the migration to run only once
   const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-  expect(loadedPerson).not.toBeNull();
-  assert(loadedPerson);
 
+  assertLoaded(loadedPerson);
   expect(loadedPerson.$jazz.owner.$jazz.raw.core.verified.isStreaming()).toBe(
     false,
   );
@@ -399,9 +395,8 @@ test("should wait for the full streaming of the parent groups", async () => {
 
   // Load the value and expect the migration to run only once
   const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-  expect(loadedPerson).not.toBeNull();
-  assert(loadedPerson);
 
+  assertLoaded(loadedPerson);
   expect(loadedPerson.$jazz.owner.$jazz.raw.core.verified.isStreaming()).toBe(
     false,
   );
@@ -465,5 +460,16 @@ test("should correctly reject the load if after the group streaming the account
 
   // Load the value and expect the migration to run only once
   const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
-  expect(loadedPerson).toBeNull();
+  expect(loadedPerson.$isLoaded).toEqual(false);
+  expect(loadedPerson.$jazz.loadingState).toEqual(
+    CoValueLoadingState.UNAVAILABLE,
+  );
+
+  await waitFor(async () => {
+    const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+    expect(loadedPerson.$isLoaded).toEqual(false);
+    expect(loadedPerson.$jazz.loadingState).toEqual(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
+  });
 });

package/src/tools/tests/patterns/quest.test.ts

@@ -1,6 +1,7 @@
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { co, z } from "../../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../../testing.js";
+import { assertLoaded } from "../utils.js";
 
 // Define the difficulty levels enum
 const difficultyLevels = ["easy", "medium", "hard"] as const;
@@ -51,7 +52,7 @@ describe("QuestSchema", () => {
 
     // Load the quest to trigger the migration
     const loadedQuest = await QuestSchema.load(quest.$jazz.id);
-    assert(loadedQuest);
+    assertLoaded(loadedQuest);
 
     // After loading, the migration should have run and filled categories
     expect(loadedQuest.categories).toEqual(["adventure"]);
@@ -76,7 +77,7 @@ describe("QuestSchema", () => {
 
     // Load the quest to ensure migration doesn't change existing categories
     const loadedQuest = await QuestSchema.load(quest.$jazz.id);
-    assert(loadedQuest);
+    assertLoaded(loadedQuest);
 
     // Categories should remain unchanged after migration
     expect(loadedQuest.categories).toEqual(["combat", "boss-fight", "endgame"]);

package/src/tools/tests/patterns/requestToJoin.test.ts

@@ -1,10 +1,12 @@
 import { assert, describe, expect, test } from "vitest";
 import { Account, Group, co, z } from "../../exports";
+import { CoValueLoadingState } from "../../internal.js";
 import {
   createJazzTestAccount,
   linkAccounts,
   setupJazzTestSync,
 } from "../../testing";
+import { assertLoaded } from "../utils.js";
 
 const RequestToJoin = co.map({
   account: Account,
@@ -98,9 +100,7 @@ async function sendRequestToJoin(organizationId: string, account: Account) {
     loadAs: account,
   });
 
-  if (!organization) {
-    throw new Error("RequestsMap not found");
-  }
+  assertLoaded(organization);
 
   const group = Group.create(account);
   group.addMember(organization.adminsGroup);
@@ -130,9 +130,7 @@ async function approveRequest(
     resolve: { statuses: true, requests: { $each: true }, mainGroup: true },
   });
 
-  if (!organization) {
-    throw new Error("Organization not found");
-  }
+  assertLoaded(organization);
 
   const request = organization.requests[user.$jazz.id];
 
@@ -165,9 +163,7 @@ async function rejectRequest(
     resolve: { statuses: true, requests: { $each: true } },
   });
 
-  if (!organization) {
-    throw new Error("Organization not found");
-  }
+  assertLoaded(organization);
 
   const request = organization.requests[user.$jazz.id];
 
@@ -201,7 +197,7 @@ describe("Request to join", () => {
       },
     });
 
-    assert(organization);
+    assertLoaded(organization);
 
     await sendRequestToJoin(organizationId, user1);
 
@@ -213,7 +209,7 @@ describe("Request to join", () => {
         loadAs: user1,
       });
 
-    assert(projectsOnUser);
+    assertLoaded(projectsOnUser);
 
     projectsOnUser.$jazz.push("project1");
 
@@ -232,7 +228,7 @@ describe("Request to join", () => {
       },
     });
 
-    assert(organization);
+    assertLoaded(organization);
 
     await sendRequestToJoin(organizationId, user1);
     await rejectRequest(organizationId, admin1, user1);
@@ -243,7 +239,9 @@ describe("Request to join", () => {
         loadAs: user1,
       });
 
-    expect(projectsOnUser).toBeNull();
+    expect(projectsOnUser.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
   });
 
   test("admin2 can see the status of the requests", async () => {
@@ -257,12 +255,12 @@ describe("Request to join", () => {
       resolve: { requests: { $each: true }, statuses: { $each: true } },
     });
 
-    assert(organization);
+    assertLoaded(organization);
     expect(organization.statuses[user1.$jazz.id]).toBe("approved");
     const requestOnAdmin2 = await RequestToJoin.load(request.$jazz.id, {
       loadAs: admin2,
     });
-    assert(requestOnAdmin2);
+    assertLoaded(requestOnAdmin2);
     expect(requestOnAdmin2.status).toBe("approved");
   });
 
@@ -276,7 +274,9 @@ describe("Request to join", () => {
     });
 
     // With the writeOnly permission, the user can download the request
-    // but not it's content
-    expect(requestOnUser2).toBeNull();
+    // but not its content
+    expect(requestOnUser2.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
   });
 });

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

@@ -9,7 +9,12 @@ import {
   isJazzRequestError,
 } from "../coValues/request.js";
 import { Account, CoPlainText, Group, co } from "../index.js";
-import { exportCoValue, importContentPieces } from "../internal.js";
+import {
+  createUnloadedCoValue,
+  CoValueLoadingState,
+  exportCoValue,
+  importContentPieces,
+} from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 
 const server = setupServer();
@@ -654,7 +659,12 @@ describe("JazzRequestError handling", () => {
 
       server.use(
         http.post("https://api.example.com/api/user", async ({ request }) => {
-          vi.spyOn(Account, "load").mockResolvedValue(null);
+          vi.spyOn(Account, "load").mockResolvedValue(
+            createUnloadedCoValue(
+              "some-covalue-id",
+              CoValueLoadingState.UNAVAILABLE,
+            ),
+          );
 
           return userRequest.handle(request, worker, async () => {
             return { bio: "test" };