jazz-tools 0.18.37 → 0.19.0

package/src/tools/subscribe/SubscriptionScope.ts

@@ -5,6 +5,7 @@ import {
   CoMap,
   type CoValue,
   type ID,
+  MaybeLoaded,
   type RefEncoded,
   type RefsToResolve,
   TypeSym,
@@ -14,7 +15,12 @@ import {
 import { applyCoValueMigrations } from "../lib/migration.js";
 import { CoValueCoreSubscription } from "./CoValueCoreSubscription.js";
 import { JazzError, type JazzErrorIssue } from "./JazzError.js";
-import type { BranchDefinition, SubscriptionValue, Unloaded } from "./types.js";
+import type {
+  BranchDefinition,
+  SubscriptionValue,
+  SubscriptionValueLoading,
+} from "./types.js";
+import { CoValueLoadingState, NotLoadedCoValueState } from "./types.js";
 import { createCoValue, myRoleForRawValue } from "./utils.js";
 
 export class SubscriptionScope<D extends CoValue> {
@@ -31,7 +37,7 @@ export class SubscriptionScope<D extends CoValue> {
    * Autoloaded child ids that are unloaded
    */
   pendingAutoloadedChildren: Set<string> = new Set();
-  value: SubscriptionValue<D, any> | Unloaded;
+  value: SubscriptionValue<D, any> | SubscriptionValueLoading;
   childErrors: Map<string, JazzError> = new Map();
   validationErrors: Map<string, JazzError> = new Map();
   errorFromChildren: JazzError | undefined;
@@ -59,16 +65,19 @@ export class SubscriptionScope<D extends CoValue> {
     public unstable_branch?: BranchDefinition,
   ) {
     this.resolve = resolve;
-    this.value = { type: "unloaded", id };
+    this.value = { type: CoValueLoadingState.LOADING, id };
 
-    let lastUpdate: RawCoValue | "unavailable" | undefined;
+    let lastUpdate:
+      | RawCoValue
+      | typeof CoValueLoadingState.UNAVAILABLE
+      | undefined;
     this.subscription = new CoValueCoreSubscription(
       node,
       id,
       (value) => {
         lastUpdate = value;
 
-        if (skipRetry && value === "unavailable") {
+        if (skipRetry && value === CoValueLoadingState.UNAVAILABLE) {
           this.handleUpdate(value);
           return;
         }
@@ -79,7 +88,7 @@ export class SubscriptionScope<D extends CoValue> {
         // - Run the migration only once
         // - Skip all the updates until the migration is done
         // - Trigger handleUpdate only with the final value
-        if (!this.migrated && value !== "unavailable") {
+        if (!this.migrated && value !== CoValueLoadingState.UNAVAILABLE) {
           if (this.migrating) {
             return;
           }
@@ -107,13 +116,13 @@ export class SubscriptionScope<D extends CoValue> {
     this.dirty = true;
   }
 
-  handleUpdate(update: RawCoValue | "unavailable") {
-    if (update === "unavailable") {
-      if (this.value.type === "unloaded") {
+  handleUpdate(update: RawCoValue | typeof CoValueLoadingState.UNAVAILABLE) {
+    if (update === CoValueLoadingState.UNAVAILABLE) {
+      if (this.value.type === CoValueLoadingState.LOADING) {
         this.updateValue(
-          new JazzError(this.id, "unavailable", [
+          new JazzError(this.id, CoValueLoadingState.UNAVAILABLE, [
             {
-              code: "unavailable",
+              code: CoValueLoadingState.UNAVAILABLE,
               message: "The value is unavailable",
               params: {
                 id: this.id,
@@ -135,11 +144,11 @@ export class SubscriptionScope<D extends CoValue> {
       myRoleForRawValue(update) !== undefined;
 
     if (!hasAccess) {
-      if (this.value.type !== "unauthorized") {
+      if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         this.updateValue(
-          new JazzError(this.id, "unauthorized", [
+          new JazzError(this.id, CoValueLoadingState.UNAUTHORIZED, [
             {
-              code: "unauthorized",
+              code: CoValueLoadingState.UNAUTHORIZED,
               message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
               params: {
                 id: this.id,
@@ -157,7 +166,7 @@ export class SubscriptionScope<D extends CoValue> {
     // after loading all the children, not one per children
     this.silenceUpdates = true;
 
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       this.updateValue(createCoValue(this.schema, update, this));
       this.loadChildren();
     } else {
@@ -182,7 +191,7 @@ export class SubscriptionScope<D extends CoValue> {
 
   computeChildErrors() {
     let issues: JazzErrorIssue[] = [];
-    let errorType: JazzError["type"] = "unavailable";
+    let errorType: JazzError["type"] = CoValueLoadingState.UNAVAILABLE;
 
     if (this.childErrors.size === 0 && this.validationErrors.size === 0) {
       return undefined;
@@ -228,10 +237,10 @@ export class SubscriptionScope<D extends CoValue> {
 
   handleChildUpdate = (
     id: string,
-    value: SubscriptionValue<any, any> | Unloaded,
+    value: SubscriptionValue<any, any> | SubscriptionValueLoading,
     key?: string,
   ) => {
-    if (value.type === "unloaded") {
+    if (value.type === CoValueLoadingState.LOADING) {
       return;
     }
 
@@ -239,7 +248,10 @@ export class SubscriptionScope<D extends CoValue> {
     this.pendingAutoloadedChildren.delete(id);
     this.childValues.set(id, value);
 
-    if (value.type === "unavailable" || value.type === "unauthorized") {
+    if (
+      value.type === CoValueLoadingState.UNAVAILABLE ||
+      value.type === CoValueLoadingState.UNAUTHORIZED
+    ) {
       this.childErrors.set(id, value.prependPath(key ?? id));
 
       this.errorFromChildren = this.computeChildErrors();
@@ -250,7 +262,7 @@ export class SubscriptionScope<D extends CoValue> {
     }
 
     if (this.shouldSendUpdates()) {
-      if (this.value.type === "loaded") {
+      if (this.value.type === CoValueLoadingState.LOADED) {
         // On child updates, we re-create the value instance to make the updates
         // seamless-immutable and so be compatible with React and the React compiler
         this.updateValue(
@@ -263,37 +275,37 @@ export class SubscriptionScope<D extends CoValue> {
   };
 
   shouldSendUpdates() {
-    if (this.value.type === "unloaded") return false;
+    if (this.value.type === CoValueLoadingState.LOADING) return false;
 
     // If the value is in error, we send the update regardless of the children statuses
-    if (this.value.type !== "loaded") return true;
+    if (this.value.type !== CoValueLoadingState.LOADED) return true;
 
     return this.pendingLoadedChildren.size === 0;
   }
 
-  getCurrentValue() {
+  getCurrentValue(): D | NotLoadedCoValueState {
     if (
-      this.value.type === "unauthorized" ||
-      this.value.type === "unavailable"
+      this.value.type === CoValueLoadingState.UNAUTHORIZED ||
+      this.value.type === CoValueLoadingState.UNAVAILABLE
     ) {
       console.error(this.value.toString());
-      return null;
+      return this.value.type;
     }
 
     if (!this.shouldSendUpdates()) {
-      return undefined;
+      return CoValueLoadingState.LOADING;
     }
 
     if (this.errorFromChildren) {
       console.error(this.errorFromChildren.toString());
-      return null;
+      return this.errorFromChildren.type;
     }
 
-    if (this.value.type === "loaded") {
+    if (this.value.type === CoValueLoadingState.LOADED) {
       return this.value.value;
     }
 
-    return undefined;
+    return CoValueLoadingState.LOADING;
   }
 
   triggerUpdate() {
@@ -307,7 +319,7 @@ export class SubscriptionScope<D extends CoValue> {
 
     if (error) {
       this.subscribers.forEach((listener) => listener(error));
-    } else if (value.type !== "unloaded") {
+    } else if (value.type !== CoValueLoadingState.LOADING) {
       this.subscribers.forEach((listener) => listener(value));
     }
 
@@ -333,16 +345,15 @@ export class SubscriptionScope<D extends CoValue> {
       this.resolve = {};
     }
 
-    if (!this.resolve.$each && !(key in this.resolve)) {
-      const resolve = this.resolve as Record<string, any>;
-
+    const resolve: Record<string, any> = this.resolve;
+    if (!resolve.$each && !(key in resolve)) {
       // Adding the key to the resolve object to resolve the key when calling loadChildren
       resolve[key] = true;
       // Track the keys that are autoloaded to flag any id on that key as autoloaded
       this.autoloadedKeys.add(key);
     }
 
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       return;
     }
 
@@ -386,7 +397,7 @@ export class SubscriptionScope<D extends CoValue> {
       throw new Error("Cannot pull a non-closed subscription scope");
     }
 
-    if (this.value.type === "loaded") {
+    if (this.value.type === CoValueLoadingState.LOADED) {
       return;
     }
 
@@ -398,9 +409,9 @@ export class SubscriptionScope<D extends CoValue> {
     const value = this.getCurrentValue();
 
     // If the value is available, trigger the listener
-    if (value) {
+    if (typeof value !== "string") {
       listener({
-        type: "loaded",
+        type: CoValueLoadingState.LOADED,
         value,
         id: this.id,
       });
@@ -461,7 +472,7 @@ export class SubscriptionScope<D extends CoValue> {
   loadChildren() {
     const { resolve } = this;
 
-    if (this.value.type !== "loaded") {
+    if (this.value.type !== CoValueLoadingState.LOADED) {
       return false;
     }
 
@@ -536,7 +547,7 @@ export class SubscriptionScope<D extends CoValue> {
               } else if (!descriptor.optional) {
                 this.validationErrors.set(
                   key,
-                  new JazzError(undefined, "unavailable", [
+                  new JazzError(undefined, CoValueLoadingState.UNAVAILABLE, [
                     {
                       code: "validationError",
                       message: `The ref on position ${key} requested on ${stream.constructor.name} is missing`,
@@ -585,7 +596,7 @@ export class SubscriptionScope<D extends CoValue> {
     if (!descriptor) {
       this.childErrors.set(
         key,
-        new JazzError(undefined, "unavailable", [
+        new JazzError(undefined, CoValueLoadingState.UNAVAILABLE, [
           {
             code: "validationError",
             message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
@@ -606,7 +617,7 @@ export class SubscriptionScope<D extends CoValue> {
       } else if (!descriptor.optional) {
         this.validationErrors.set(
           key,
-          new JazzError(undefined, "unavailable", [
+          new JazzError(undefined, CoValueLoadingState.UNAVAILABLE, [
             {
               code: "validationError",
               message: `The ref ${key} requested on ${map.constructor.name} is missing`,
@@ -645,7 +656,7 @@ export class SubscriptionScope<D extends CoValue> {
     } else if (!descriptor.optional) {
       this.validationErrors.set(
         key,
-        new JazzError(undefined, "unavailable", [
+        new JazzError(undefined, CoValueLoadingState.UNAVAILABLE, [
           {
             code: "validationError",
             message: `The ref on position ${key} requested on ${list.constructor.name} is missing`,
@@ -674,7 +685,7 @@ export class SubscriptionScope<D extends CoValue> {
       this.autoloaded.add(id);
     }
 
-    const skipInvalid = typeof query === "object" && query.$onError === null;
+    const skipInvalid = typeof query === "object" && query.$onError === "catch";
 
     if (skipInvalid) {
       if (key) {

package/src/tools/subscribe/index.ts

@@ -1,5 +1,7 @@
 import type { CoValue, CoValueClass, RefEncoded } from "../internal.js";
+import { createUnloadedCoValue } from "../internal.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
+import { CoValueLoadingState } from "./types.js";
 
 export function getSubscriptionScope<D extends CoValue>(value: D) {
   const subscriptionScope = value.$jazz._subscriptionScope;
@@ -56,10 +58,13 @@ export function accessChildByKey<D extends CoValue>(
 
   const value = subscriptionScope.childValues.get(childId);
 
-  if (value?.type === "loaded") {
+  if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
   } else {
-    return null;
+    return createUnloadedCoValue(
+      childId,
+      value?.type ?? CoValueLoadingState.LOADING,
+    );
   }
 }
 
@@ -82,9 +87,12 @@ export function accessChildById<D extends CoValue>(
 
   const value = subscriptionScope.childValues.get(childId);
 
-  if (value?.type === "loaded") {
+  if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
   } else {
-    return null;
+    return createUnloadedCoValue(
+      childId,
+      value?.type ?? CoValueLoadingState.LOADING,
+    );
   }
 }

package/src/tools/subscribe/types.ts

@@ -7,9 +7,43 @@ import type {
 } from "../internal.js";
 import type { JazzError } from "./JazzError.js";
 
+export const CoValueLoadingState = {
+  /**
+   * The coValue is loaded.
+   */
+  LOADED: "loaded",
+  /**
+   * The coValue is being loaded.
+   */
+  LOADING: "loading",
+  /**
+   * The coValue was loaded but the account is not authorized to access it.
+   */
+  UNAUTHORIZED: "unauthorized",
+  /**
+   * Tried to load the coValue but failed.
+   */
+  UNAVAILABLE: "unavailable",
+} as const;
+
+export type CoValueLoadingState =
+  (typeof CoValueLoadingState)[keyof typeof CoValueLoadingState];
+
+export type NotLoadedCoValueState =
+  | typeof CoValueLoadingState.LOADING
+  | typeof CoValueLoadingState.UNAUTHORIZED
+  | typeof CoValueLoadingState.UNAVAILABLE;
+
 export type SubscriptionValue<D extends CoValue, R extends RefsToResolve<D>> =
-  | { type: "loaded"; value: Resolved<D, R>; id: string }
+  | {
+      type: typeof CoValueLoadingState.LOADED;
+      value: Resolved<D, R>;
+      id: string;
+    }
   | JazzError;
-export type Unloaded = { type: "unloaded"; id: string };
+export type SubscriptionValueLoading = {
+  type: typeof CoValueLoadingState.LOADING;
+  id: string;
+};
 
 export type BranchDefinition = { name: string; owner?: Group | Account | null };

package/src/tools/subscribe/utils.ts

@@ -8,6 +8,7 @@ import {
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
+import { CoValueLoadingState } from "./types.js";
 
 export function myRoleForRawValue(raw: RawCoValue): Role | undefined {
   const rawOwner = raw.group;
@@ -36,7 +37,7 @@ export function createCoValue<D extends CoValue>(
   });
 
   return {
-    type: "loaded" as const,
+    type: CoValueLoadingState.LOADED,
     value: freshValueInstance,
     id: subscriptionScope.id,
   };

package/src/tools/testing.ts

@@ -16,9 +16,14 @@ import {
   coValueClassFromCoValueClassOrSchema,
   createAnonymousJazzContext,
   createJazzContext,
+  CoValue,
+  LoadedAndRequired,
+  MaybeLoaded,
   randomSessionProvider,
 } from "./internal.js";
 
+export { assertLoaded } from "./lib/utils.js";
+
 const syncServer: { current: LocalNode | null; asyncPeers: boolean } = {
   current: null,
   asyncPeers: false,

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

@@ -1,5 +1,11 @@
 import { assert, beforeEach, describe, expect, test, vi } from "vitest";
-import { Group, co, exportCoValue, z } from "../exports.js";
+import {
+  CoValueLoadingState,
+  Group,
+  co,
+  exportCoValue,
+  z,
+} from "../exports.js";
 import { CoValueCoreSubscription } from "../subscribe/CoValueCoreSubscription.js";
 import {
   createJazzTestAccount,
@@ -462,7 +468,7 @@ describe("CoValueCoreSubscription", async () => {
       await waitFor(() => expect(listener).toHaveBeenCalled());
 
       // Should report unavailable when loading fails
-      expect(lastResult).toBe("unavailable");
+      expect(lastResult).toBe(CoValueLoadingState.UNAVAILABLE);
 
       subscription.unsubscribe();
     });
@@ -493,7 +499,7 @@ describe("CoValueCoreSubscription", async () => {
       await waitFor(() => expect(listener).toHaveBeenCalled());
 
       // Should report unavailable when loading fails
-      expect(lastResult).toBe("unavailable");
+      expect(lastResult).toBe(CoValueLoadingState.UNAVAILABLE);
 
       subscription.unsubscribe();
     });
@@ -542,7 +548,7 @@ describe("CoValueCoreSubscription", async () => {
       await waitFor(() => expect(listener).toHaveBeenCalled());
 
       // Should report unavailable when loading fails
-      expect(lastResult).toBe("unavailable");
+      expect(lastResult).toBe(CoValueLoadingState.UNAVAILABLE);
 
       subscription.unsubscribe();
     });

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

@@ -1,6 +1,6 @@
 import { StorageAPI } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 import {
   Account,
   AccountClass,
@@ -28,6 +28,7 @@ import {
   coValueClassFromCoValueClassOrSchema,
 } from "../internal";
 import {
+  assertLoaded,
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
@@ -101,7 +102,8 @@ describe("ContextManager", () => {
 
     const context = getCurrentValue();
 
-    expect(context.me.profile?.name).toBe("Anonymous user");
+    assertLoaded(context.me.profile);
+    expect(context.me.profile.name).toBe("Anonymous user");
     expect(context.node).toBeDefined();
     expect(manager.getCurrentValue()).toBeDefined();
   });
@@ -113,7 +115,8 @@ describe("ContextManager", () => {
 
     const context = getCurrentValue();
 
-    expect(context.me.profile?.name).toBe("Test User");
+    assertLoaded(context.me.profile);
+    expect(context.me.profile.name).toBe("Test User");
     expect(context.node).toBeDefined();
     expect(manager.getCurrentValue()).toBeDefined();
   });
@@ -489,7 +492,10 @@ describe("ContextManager", () => {
       },
     });
 
-    expect(me.root.transferredRoot?.value).toBe("Hello");
+    const transferredRoot = me.root.transferredRoot;
+    assert(transferredRoot);
+    assertLoaded(transferredRoot);
+    expect(transferredRoot.value).toBe("Hello");
   });
 
   test("handles registration of new account", async () => {
@@ -501,7 +507,8 @@ describe("ContextManager", () => {
 
     expect(accountId).toBeDefined();
     const context = getCurrentValue();
-    expect(context.me.profile?.name).toBe("Test User");
+    assertLoaded(context.me.profile);
+    expect(context.me.profile.name).toBe("Test User");
     expect(context.me.$jazz.id).toBe(accountId);
   });
 

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

@@ -6,7 +6,8 @@ import {
   setActiveAccount,
   setupJazzTestSync,
 } from "../testing.js";
-import { setupTwoNodes } from "./utils.js";
+import { assertLoaded, setupTwoNodes } from "./utils.js";
+import { CoValueLoadingState } from "../internal.js";
 
 beforeEach(async () => {
   await setupJazzTestSync();
@@ -32,7 +33,7 @@ test("waitForAllCoValuesSync should resolve when all the values are synced", asy
 
   for (const map of maps) {
     const loadedMap = await serverNode.load(map.$jazz.raw.id);
-    expect(loadedMap).not.toBe("unavailable");
+    expect(loadedMap).not.toBe(CoValueLoadingState.UNAVAILABLE);
   }
 });
 
@@ -46,7 +47,7 @@ test("waitForSync should resolve when the value is uploaded", async () => {
 
   const loadedAccount = await serverNode.load(clientAccount.$jazz.raw.id);
 
-  expect(loadedAccount).not.toBe("unavailable");
+  expect(loadedAccount).not.toBe(CoValueLoadingState.UNAVAILABLE);
 });
 
 test("isMe gets updated correctly when switching accounts", async () => {
@@ -86,11 +87,13 @@ test("Me gets updated correctly when creating a new account as active", async ()
 
 test("accounts should sync correctly", async () => {
   const account = await createJazzTestAccount({ isCurrentActiveAccount: true });
-  account.profile!.$jazz.set("name", "test 1");
+  assertLoaded(account.profile);
+  account.profile.$jazz.set("name", "test 1");
   const otherAccount = await createJazzTestAccount({
     isCurrentActiveAccount: true,
   });
-  otherAccount.profile!.$jazz.set("name", "test 2");
+  assertLoaded(otherAccount.profile);
+  otherAccount.profile.$jazz.set("name", "test 2");
 
   await linkAccounts(account, otherAccount);
 
@@ -98,8 +101,14 @@ test("accounts should sync correctly", async () => {
 
   group.addMember(otherAccount, "writer");
 
-  expect(group.members[0]?.account.profile!.name).toBe("test 1");
-  expect(group.members[1]?.account.profile!.name).toBe("test 2");
+  const accountMember = group.members[0]?.account;
+  assert(accountMember);
+  assertLoaded(accountMember.profile);
+  expect(accountMember.profile.name).toBe("test 1");
+  const otherAccountMember = group.members[1]?.account;
+  assert(otherAccountMember);
+  assertLoaded(otherAccountMember.profile);
+  expect(otherAccountMember.profile.name).toBe("test 2");
 });
 
 test("loading accounts should work", async () => {
@@ -118,7 +127,7 @@ test("loading accounts should work", async () => {
     },
   });
 
-  assert(loadedAccount);
+  assertLoaded(loadedAccount);
   expect(loadedAccount.profile.name).toBe("test 1");
 });
 
@@ -133,8 +142,9 @@ test("loading raw accounts should work", async () => {
     loadAs: account,
   });
 
-  assert(loadedAccount);
-  expect(loadedAccount.profile!.name).toBe("test 1");
+  assertLoaded(loadedAccount);
+  assertLoaded(loadedAccount.profile);
+  expect(loadedAccount.profile.name).toBe("test 1");
 });
 
 describe("co.profile() schema", () => {
@@ -221,7 +231,7 @@ test("cannot update account profile properties directly", async () => {
     },
   });
 
-  assert(account.profile);
+  assertLoaded(account.profile);
 
   // @ts-expect-error - cannot update profile properties directly
   expect(() => (account.profile.name = "test 2")).toThrow(
@@ -294,7 +304,7 @@ describe("root and profile", () => {
       },
     });
 
-    assert(bobAccountLoadedFromAlice);
+    assertLoaded(bobAccountLoadedFromAlice);
 
     expect(bobAccountLoadedFromAlice.profile.name).toBe("Bob");
     expect(bobAccountLoadedFromAlice.root.name).toBe("Bob");

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

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { CoPlainText, Loaded, co, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
-import { waitFor } from "./utils.js";
+import { assertLoaded, waitFor } from "./utils.js";
 
 describe("co.discriminatedUnion", () => {
   beforeEach(async () => {
@@ -277,7 +277,8 @@ describe("co.discriminatedUnion", () => {
 
     const dog = Dog.create({ type: "dog" });
     const loadedPet = await Pet.load(dog.$jazz.id);
-    expect(loadedPet?.type).toEqual("dog");
+    assertLoaded(loadedPet);
+    expect(loadedPet.type).toEqual("dog");
   });
 
   test("subscribe to CoValue instances using the DiscriminatedUnion schema", async () => {
@@ -343,7 +344,9 @@ describe("co.discriminatedUnion", () => {
 
     const loadedAnimal = await Animal.load(animal.$jazz.id);
 
-    expect(loadedAnimal?.breed?.type).toEqual("collie");
+    assertLoaded(loadedAnimal);
+    assertLoaded(loadedAnimal.breed);
+    expect(loadedAnimal.breed.type).toEqual("collie");
   });
 
   test("should work with a nested co.discriminatedUnion", async () => {
@@ -365,6 +368,7 @@ describe("co.discriminatedUnion", () => {
 
     const loadedAnimal = await Animal.load(animal.$jazz.id);
 
-    expect(loadedAnimal?.type).toEqual("collie");
+    assertLoaded(loadedAnimal);
+    expect(loadedAnimal.type).toEqual("collie");
   });
 });