jazz-tools 0.18.38 → 0.19.0

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

@@ -10,6 +10,7 @@ import {
   z,
 } from "../exports.js";
 import { createJazzTestAccount } from "../testing.js";
+import { assertLoaded } from "./utils.js";
 
 const RedButtonWidget = co.map({
   type: z.literal("button"),
@@ -87,9 +88,12 @@ describe("SchemaUnion", () => {
       },
     );
 
-    expect(loadedButtonWidget?.type).toBe("button");
-    expect(loadedSliderWidget?.type).toBe("slider");
-    expect(loadedCheckboxWidget?.type).toBe("checkbox");
+    assertLoaded(loadedButtonWidget);
+    expect(loadedButtonWidget.type).toBe("button");
+    assertLoaded(loadedSliderWidget);
+    expect(loadedSliderWidget.type).toBe("slider");
+    assertLoaded(loadedCheckboxWidget);
+    expect(loadedCheckboxWidget.type).toBe("checkbox");
   });
 
   it("should integrate with subscribeToCoValue correctly", async () => {

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

@@ -9,6 +9,7 @@ import {
 } from "vitest";
 import { Account, Group, cojsonInternals, z } from "../index.js";
 import {
+  CoValueLoadingState,
   Loaded,
   co,
   coValueClassFromCoValueClassOrSchema,
@@ -19,7 +20,7 @@ import {
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing.js";
-import { setupAccount, waitFor } from "./utils.js";
+import { assertLoaded, setupAccount, waitFor } from "./utils.js";
 import { getSubscriptionScope } from "../subscribe/index.js";
 
 cojsonInternals.setCoValueLoadingRetryDelay(300);
@@ -85,9 +86,10 @@ describe("subscribeToCoValue", () => {
       expect(updateFn).toHaveBeenCalled();
     });
 
-    expect(result).not.toBeNull();
     expect(result?.$jazz.id).toBe(chatRoom.$jazz.id);
-    expect(result?.messages).toEqual(null);
+    expect(result?.messages.$jazz.loadingState).toEqual(
+      CoValueLoadingState.LOADING,
+    );
     expect(result?.name).toBe("General");
 
     updateFn.mockClear();
@@ -906,8 +908,8 @@ describe("subscribeToCoValue", () => {
 
     spy.mockClear();
 
-    assert(personOnWriter1);
-    assert(personOnWriter2);
+    assertLoaded(personOnWriter1);
+    assertLoaded(personOnWriter2);
     personOnWriter1.$jazz.set("name", "writer1");
     personOnWriter2.$jazz.set("name", "writer2");
 
@@ -992,7 +994,7 @@ describe("subscribeToCoValue", () => {
     });
 
     assert(result);
-    expect(result[0]).toBe(null);
+    expect(result[0]?.$jazz.loadingState).toBe(CoValueLoadingState.LOADING);
 
     updateFn.mockClear();
 
@@ -1072,30 +1074,40 @@ describe("subscribeToCoValue", () => {
     onTestFinished(unsubscribe);
 
     await waitFor(() => {
-      expect(result?.[0]?.name).toBe("Guido");
-      expect(result?.[0]?.dog?.name).toBe("Giggino");
+      assert(result?.[0]);
+      expect(result[0].name).toBe("Guido");
+      assertLoaded(result[0].dog);
+      expect(result[0].dog.name).toBe("Giggino");
     });
 
     await waitFor(() => {
-      expect(result?.[1]?.name).toBe("John");
-      expect(result?.[1]?.dog?.name).toBe("Rex");
+      assert(result?.[1]);
+      expect(result[1].name).toBe("John");
+      assertLoaded(result[1].dog);
+      expect(result[1].dog.name).toBe("Rex");
     });
 
     await waitFor(() => {
-      expect(result?.[2]?.name).toBe("Jane");
-      expect(result?.[2]?.dog?.name).toBe("Bella");
+      assert(result?.[2]);
+      expect(result[2].name).toBe("Jane");
+      assertLoaded(result[2].dog);
+      expect(result[2].dog.name).toBe("Bella");
     });
 
     list[0]!.$jazz.set("dog", Dog.create({ name: "Ninja" }));
 
     await waitFor(() => {
-      expect(result?.[0]?.dog).toBe(null);
+      expect(result?.[0]?.dog.$jazz.loadingState).toBe(
+        CoValueLoadingState.UNAUTHORIZED,
+      );
     });
 
     list[1]!.$jazz.set("dog", Dog.create({ name: "Pinkie" }, everyone));
 
     await waitFor(() => {
-      expect(result?.[1]?.dog?.name).toBe("Pinkie");
+      assert(result?.[1]);
+      assertLoaded(result[1].dog);
+      expect(result[1].dog.name).toBe("Pinkie");
     });
 
     expect(onUnavailable).not.toHaveBeenCalled();
@@ -1168,18 +1180,24 @@ describe("subscribeToCoValue", () => {
     onTestFinished(unsubscribe);
 
     await waitFor(() => {
-      expect(result?.[0]?.name).toBe("Guido");
-      expect(result?.[0]?.dog?.name).toBe("Giggino");
+      assert(result?.[0]);
+      expect(result[0].name).toBe("Guido");
+      assertLoaded(result[0].dog);
+      expect(result[0].dog.name).toBe("Giggino");
     });
 
     await waitFor(() => {
-      expect(result?.[1]?.name).toBe("John");
-      expect(result?.[1]?.dog?.name).toBe("Rex");
+      assert(result?.[1]);
+      expect(result[1].name).toBe("John");
+      assertLoaded(result[1].dog);
+      expect(result[1].dog.name).toBe("Rex");
     });
 
     await waitFor(() => {
-      expect(result?.[2]?.name).toBe("Jane");
-      expect(result?.[2]?.dog?.name).toBe("Bella");
+      assert(result?.[2]);
+      expect(result[2].name).toBe("Jane");
+      assertLoaded(result[2].dog);
+      expect(result[2].dog.name).toBe("Bella");
     });
 
     expect(onUnavailable).not.toHaveBeenCalled();
@@ -1312,7 +1330,7 @@ describe("getSubscriptionScope", () => {
   describe("when the coValue already has a subscription scope", () => {
     it("returns that subscription scope", async () => {
       const loadedPerson = await Person.load(person.$jazz.id);
-      assert(loadedPerson);
+      assertLoaded(loadedPerson);
       const subscriptionScope = loadedPerson.$jazz._subscriptionScope;
       expect(subscriptionScope).toBeDefined();
       expect(getSubscriptionScope(loadedPerson)).toBe(subscriptionScope);

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

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, test } from "vitest";
 import { Account, CoMap, Group, co, z } from "../exports";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing";
+import { assertLoaded } from "./utils";
 
 describe("Jazz Test Sync", () => {
   beforeEach(async () => {
@@ -20,8 +21,8 @@ describe("Jazz Test Sync", () => {
 
     // Verify account2 can see the group
     const loadedMap = await CoMap.load(map.$jazz.id, { loadAs: account2 });
-    expect(loadedMap).toBeDefined();
-    expect(loadedMap?.$jazz.raw.get("test")).toBe("value");
+    assertLoaded(loadedMap);
+    expect(loadedMap.$jazz.raw.get("test")).toBe("value");
   });
 
   test("correctly set the globalMe before starting the migration", async () => {

package/src/tools/tests/utils.ts

@@ -1,3 +1,4 @@
+import { assert } from "vitest";
 import { AccountClass, isControlledAccount } from "../coValues/account";
 
 import { CoID, LocalNode, RawCoValue } from "cojson";
@@ -8,7 +9,13 @@ import {
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
 } from "../index";
-import { CoValueFromRaw } from "../internal";
+import {
+  CoValue,
+  CoValueFromRaw,
+  CoValueLoadingState,
+  MaybeLoaded,
+  LoadedAndRequired,
+} from "../internal";
 
 const Crypto = await WasmCrypto.create();
 
@@ -133,8 +140,14 @@ export async function loadCoValueOrFail<V extends RawCoValue>(
   id: CoID<V>,
 ): Promise<V> {
   const value = await node.load(id);
-  if (value === "unavailable") {
+  if (value === CoValueLoadingState.UNAVAILABLE) {
     throw new Error("CoValue not found");
   }
   return value;
 }
+
+export function assertLoaded<T extends MaybeLoaded<CoValue>>(
+  coValue: T,
+): asserts coValue is LoadedAndRequired<T> {
+  assert(coValue.$isLoaded, "CoValue is not loaded");
+}