jazz-tools 0.19.3 → 0.19.4

package/src/svelte/jazz.class.svelte.ts

@@ -17,8 +17,8 @@ import type {
 import {
   coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
-  createUnloadedCoValue,
   CoValueLoadingState,
+  getUnloadedCoValueWithoutId,
 } from "jazz-tools";
 import { untrack } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
@@ -55,11 +55,9 @@ export class CoState<
   // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
   R extends ResolveQuery<V> = SchemaResolveQuery<V>,
 > {
-  #value: MaybeLoaded<Loaded<V, R>> = createUnloadedCoValue(
-    "",
+  #value: MaybeLoaded<Loaded<V, R>> = getUnloadedCoValueWithoutId(
     CoValueLoadingState.LOADING,
   );
-  #previousValue: MaybeLoaded<CoValue> | undefined = undefined;
   #ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
   #id: CoStateId;
   #subscribe: () => void;
@@ -86,9 +84,9 @@ export class CoState<
       const options = this.#options;
 
       return untrack(() => {
-        if (!ctx || !id) {
+        if (!id) {
           return this.update(
-            createUnloadedCoValue(id ?? "", CoValueLoadingState.UNAVAILABLE),
+            getUnloadedCoValueWithoutId(CoValueLoadingState.UNAVAILABLE),
           );
         }
         const agent = "me" in ctx ? ctx.me : ctx.guest;
@@ -101,15 +99,11 @@ export class CoState<
             // @ts-expect-error The resolve query type isn't compatible with the coValueClassFromCoValueClassOrSchema conversion
             resolve,
             loadAs: agent,
-            onUnavailable: () => {
-              this.update(
-                createUnloadedCoValue(id, CoValueLoadingState.UNAVAILABLE),
-              );
+            onUnavailable: (value) => {
+              this.update(value);
             },
-            onUnauthorized: () => {
-              this.update(
-                createUnloadedCoValue(id, CoValueLoadingState.UNAUTHORIZED),
-              );
+            onUnauthorized: (value) => {
+              this.update(value);
             },
             syncResolution: true,
             unstable_branch: options?.unstable_branch,
@@ -130,7 +124,6 @@ export class CoState<
     if (shouldSkipUpdate(value, this.#value)) {
       return;
     }
-    this.#previousValue = value;
     this.#value = value;
     this.#update();
   }
@@ -148,11 +141,10 @@ export class AccountCoState<
   // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
   R extends ResolveQuery<A> = SchemaResolveQuery<A>,
 > {
-  #value: MaybeLoaded<Loaded<A, R>> = createUnloadedCoValue(
-    "",
+  #value: MaybeLoaded<Loaded<A, R>> = getUnloadedCoValueWithoutId(
     CoValueLoadingState.LOADING,
   );
-  #ctx = getJazzContext<InstanceOfSchema<A>>();
+  #ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
   #subscribe: () => void;
   #options: CoStateOptions<A, R> | undefined;
   #update = () => {};
@@ -174,9 +166,9 @@ export class AccountCoState<
       const options = this.#options;
 
       return untrack(() => {
-        if (!ctx || !("me" in ctx)) {
+        if (!("me" in ctx)) {
           return this.update(
-            createUnloadedCoValue("", CoValueLoadingState.UNAVAILABLE),
+            getUnloadedCoValueWithoutId(CoValueLoadingState.UNAVAILABLE),
           );
         }
 
@@ -189,21 +181,11 @@ export class AccountCoState<
           {
             resolve,
             loadAs: me,
-            onUnavailable: () => {
-              this.update(
-                createUnloadedCoValue(
-                  me.$jazz.id,
-                  CoValueLoadingState.UNAVAILABLE,
-                ),
-              );
+            onUnavailable: (value) => {
+              this.update(value);
             },
-            onUnauthorized: () => {
-              this.update(
-                createUnloadedCoValue(
-                  me.$jazz.id,
-                  CoValueLoadingState.UNAUTHORIZED,
-                ),
-              );
+            onUnauthorized: (value) => {
+              this.update(value);
             },
             syncResolution: true,
             unstable_branch: options?.unstable_branch,

package/src/tools/coValues/coFeed.ts

@@ -512,13 +512,16 @@ function entryFromRawEntry<Item>(
       }
     },
     get by() {
-      return (
-        accountID &&
-        accessChildById(accessFrom, accountID, {
-          ref: Account,
-          optional: false,
-        })
-      );
+      if (!accountID) return null;
+
+      const account = accessChildById(accessFrom, accountID, {
+        ref: Account,
+        optional: false,
+      }) as Account;
+
+      if (!account.$isLoaded) return null;
+
+      return account;
     },
     madeAt: rawEntry.at,
     tx: rawEntry.tx,

package/src/tools/coValues/coMap.ts

@@ -1051,13 +1051,16 @@ function getEditFromRaw(
           )
         : undefined,
     get by() {
-      return (
-        rawEdit.by &&
-        accessChildById(target, rawEdit.by, {
-          ref: Account,
-          optional: false,
-        })
-      );
+      if (!rawEdit.by) return null;
+
+      const account = accessChildById(target, rawEdit.by, {
+        ref: Account,
+        optional: false,
+      }) as Account;
+
+      if (!account.$isLoaded) return null;
+
+      return account;
     },
     madeAt: rawEdit.at,
     key,

package/src/tools/coValues/group.ts

@@ -178,7 +178,11 @@ export class Group extends CoValueBase implements CoValue {
           ref,
           get account() {
             // Accounts values are non-nullable because are loaded as dependencies
-            return accessChildById(group, accountID, refEncodedAccountSchema);
+            return accessChildById(
+              group,
+              accountID,
+              refEncodedAccountSchema,
+            ) as Account;
           },
         });
       }
@@ -410,7 +414,7 @@ export function getCoValueOwner(coValue: CoValue): Group {
     ref: RegisteredSchemas["Group"],
     optional: false,
   });
-  if (!group) {
+  if (!group.$isLoaded) {
     throw new Error("CoValue has no owner");
   }
   return group;

package/src/tools/coValues/interfaces.ts

@@ -107,6 +107,23 @@ export function isCoValueClass<V extends CoValue>(
  */
 export type ID<T> = string;
 
+const unloadedCoValueStates = new Map<
+  NotLoadedCoValueState,
+  NotLoaded<CoValue>
+>();
+
+export function getUnloadedCoValueWithoutId<T extends CoValue>(
+  loadingState: NotLoadedCoValueState,
+): NotLoaded<T> {
+  const value = unloadedCoValueStates.get(loadingState);
+  if (value) {
+    return value;
+  }
+  const newValue = createUnloadedCoValue("", loadingState);
+  unloadedCoValueStates.set(loadingState, newValue);
+  return newValue;
+}
+
 export function createUnloadedCoValue<T extends CoValue>(
   id: ID<T>,
   loadingState: NotLoadedCoValueState,
@@ -159,12 +176,8 @@ export function loadCoValue<
         loadAs: options.loadAs,
         syncResolution: true,
         skipRetry: options.skipRetry,
-        onUnavailable: () => {
-          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAVAILABLE));
-        },
-        onUnauthorized: () => {
-          resolve(createUnloadedCoValue(id, CoValueLoadingState.UNAUTHORIZED));
-        },
+        onUnavailable: resolve,
+        onUnauthorized: resolve,
         unstable_branch: options.unstable_branch,
       },
       (value, unsubscribe) => {
@@ -215,8 +228,8 @@ export type SubscribeListenerOptions<
 > = {
   resolve?: RefsToResolveStrict<V, R>;
   loadAs?: Account | AnonymousJazzAgent;
-  onUnauthorized?: () => void;
-  onUnavailable?: () => void;
+  onUnauthorized?: (value: NotLoaded<V>) => void;
+  onUnavailable?: (value: NotLoaded<V>) => void;
   unstable_branch?: BranchDefinition;
 };
 
@@ -290,8 +303,8 @@ export function subscribeToCoValue<
   options: {
     resolve?: RefsToResolveStrict<V, R>;
     loadAs: Account | AnonymousJazzAgent;
-    onUnavailable?: () => void;
-    onUnauthorized?: () => void;
+    onUnavailable?: (value: NotLoaded<V>) => void;
+    onUnauthorized?: (value: NotLoaded<V>) => void;
     syncResolution?: boolean;
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
@@ -318,35 +331,42 @@ export function subscribeToCoValue<
     options.unstable_branch,
   );
 
-  const handleUpdate = (value: SubscriptionValue<V, any>) => {
+  const handleUpdate = () => {
     if (unsubscribed) return;
 
-    if (value.type === CoValueLoadingState.UNAVAILABLE) {
-      options.onUnavailable?.();
+    const value = rootNode.getCurrentValue();
 
-      // Don't log unavailable errors when `loadUnique` or `upsertUnique` are used
-      if (!options.skipRetry) {
-        console.error(value.toString());
-      }
-    } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
-      options.onUnauthorized?.();
+    if (value.$isLoaded) {
+      listener(value as Resolved<V, R>, unsubscribe);
+      return;
+    }
 
-      console.error(value.toString());
-    } else if (value.type === CoValueLoadingState.LOADED) {
-      listener(value.value as Resolved<V, R>, unsubscribe);
+    switch (value.$jazz.loadingState) {
+      case CoValueLoadingState.UNAVAILABLE:
+        options.onUnavailable?.(value);
+
+        // Don't log unavailable errors when `loadUnique` or `upsertUnique` are used
+        if (!options.skipRetry) {
+          console.error(value.toString());
+        }
+        break;
+      case CoValueLoadingState.UNAUTHORIZED:
+        options.onUnauthorized?.(value);
+        console.error(value.toString());
+        break;
     }
   };
 
   let shouldDefer = !options.syncResolution;
 
-  rootNode.setListener((value) => {
+  rootNode.setListener(() => {
     if (shouldDefer) {
       shouldDefer = false;
       Promise.resolve().then(() => {
-        handleUpdate(value);
+        handleUpdate();
       });
     } else {
-      handleUpdate(value);
+      handleUpdate();
     }
   });
 
@@ -366,8 +386,8 @@ export function subscribeToExistingCoValue<
   options:
     | {
         resolve?: RefsToResolveStrict<V, R>;
-        onUnavailable?: () => void;
-        onUnauthorized?: () => void;
+        onUnavailable?: (value: NotLoaded<V>) => void;
+        onUnauthorized?: (value: NotLoaded<V>) => void;
         unstable_branch?: BranchDefinition;
       }
     | undefined,
@@ -703,7 +723,7 @@ function loadContentPiecesFromSubscription(
 
   const currentValue = subscription.getCurrentValue();
 
-  if (typeof currentValue !== "string") {
+  if (currentValue.$isLoaded) {
     const core = currentValue.$jazz.raw.core as AvailableCoValueCore;
     loadContentPiecesFromCoValue(core, valuesExported, contentPieces);
   }

package/src/tools/coValues/promise.ts

@@ -0,0 +1,34 @@
+export class CoValuePromise<T> extends Promise<T> {
+  status: "pending" | "fulfilled" | "rejected" = "pending";
+  value: T | undefined;
+  reason: unknown | undefined;
+
+  static getRejected<T = never>(reason?: unknown): CoValuePromise<T> {
+    return new CoValuePromise<T>((resolve, reject) => {
+      reject(reason);
+    });
+  }
+
+  static getFulfilled<T>(value: T): CoValuePromise<T> {
+    return new CoValuePromise<T>((resolve) => {
+      resolve(value);
+    });
+  }
+
+  constructor(
+    executor: (
+      resolve: (value: T) => void,
+      reject: (reason?: unknown) => void,
+    ) => void,
+  ) {
+    super((resolve, reject) => {
+      const _resolve = (value: T) => {
+        resolve(value);
+      };
+      const _reject = (reason?: unknown) => {
+        reject(reason);
+      };
+      executor(_resolve, _reject);
+    });
+  }
+}

package/src/tools/coValues/request.ts

@@ -14,8 +14,6 @@ import {
   CoMapSchemaInit,
   CoValueClass,
   CoreCoMapSchema,
-  CoValueLoadingState,
-  createUnloadedCoValue,
   Group,
   Loaded,
   ResolveQuery,
@@ -377,9 +375,6 @@ export class HttpRoute<
     const as = options?.owner ?? Account.getMe();
 
     const target = await loadWorkerAccountOrGroup(this.workerId, as);
-    if (!target.$isLoaded) {
-      throw new JazzRequestError("Worker account not found", 400);
-    }
 
     const response = await fetch(this.url, {
       method: "POST",
@@ -621,20 +616,29 @@ async function loadWorkerAccountOrGroup(id: string, loadAs: Account) {
   const coValue = await node.loadCoValueCore(id as `co_z${string}`);
 
   if (!coValue.isAvailable()) {
-    return createUnloadedCoValue(id, CoValueLoadingState.UNAVAILABLE);
+    throw new JazzRequestError("Worker account not found", 400);
   }
 
   const content = coValue.getCurrentContent();
 
   if (content instanceof RawAccount) {
-    return Account.load(content.id, {
+    const account = await Account.load(content.id, {
       loadAs,
     });
+    if (!account.$isLoaded) {
+      throw new JazzRequestError("Worker account not found", 400);
+    }
+    return account;
   }
 
-  return Group.load(content.id, {
+  const group = await Group.load(content.id, {
     loadAs,
   });
+
+  if (!group.$isLoaded) {
+    throw new JazzRequestError("Worker group not found", 400);
+  }
+  return group;
 }
 
 function defaultGetToken(request: Request) {

package/src/tools/exports.ts

@@ -64,6 +64,7 @@ export {
   Ref,
   createUnloadedCoValue,
   unstable_loadUnique,
+  getUnloadedCoValueWithoutId,
 } from "./internal.js";
 
 export {

package/src/tools/implementation/refs.ts

@@ -53,29 +53,21 @@ export class Ref<out V extends CoValue> {
     }
 
     if (!node) {
-      return createUnloadedCoValue(this.id, CoValueLoadingState.LOADING);
+      return createUnloadedCoValue(this.id, CoValueLoadingState.UNAVAILABLE);
     }
 
-    const value = node.value;
+    const value = node.getCurrentValue();
 
-    if (value?.type === CoValueLoadingState.LOADED) {
-      return value.value as V;
+    if (value.$isLoaded) {
+      return value as V;
     } else {
       return new Promise((resolve) => {
         const unsubscribe = node.subscribe((value) => {
-          if (value?.type === CoValueLoadingState.LOADED) {
-            unsubscribe();
-            resolve(value.value as V);
-          } else if (value?.type === CoValueLoadingState.UNAVAILABLE) {
-            unsubscribe();
-            resolve(
-              createUnloadedCoValue(this.id, CoValueLoadingState.UNAVAILABLE),
-            );
-          } else if (value?.type === CoValueLoadingState.UNAUTHORIZED) {
+          const currentValue = node.getCurrentValue();
+
+          if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
             unsubscribe();
-            resolve(
-              createUnloadedCoValue(this.id, CoValueLoadingState.UNAUTHORIZED),
-            );
+            resolve(currentValue as V);
           }
 
           if (subscriptionScope.closed) {
@@ -86,7 +78,7 @@ export class Ref<out V extends CoValue> {
     }
   }
 
-  get value(): V | null | undefined {
+  get value(): MaybeLoaded<V> {
     return accessChildById(this.parent, this.id, this.schema);
   }
 }

package/src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts

@@ -60,16 +60,33 @@ function makeCodecCoField(
   });
 }
 
-export function schemaFieldToCoFieldDef(schema: SchemaField) {
+// CoFieldDefs are inherently type-unsafe. This type exists only for documentation purposes.
+type CoFieldDef = any;
+const schemaFieldCache = new WeakMap<SchemaField, CoFieldDef>();
+
+function cacheSchemaField(schema: SchemaField, value: CoFieldDef): CoFieldDef {
+  schemaFieldCache.set(schema, value);
+  return value;
+}
+
+export function schemaFieldToCoFieldDef(schema: SchemaField): CoFieldDef {
+  const cachedCoFieldDef = schemaFieldCache.get(schema);
+  if (cachedCoFieldDef !== undefined) {
+    return cachedCoFieldDef;
+  }
+
   if (isCoValueClass(schema)) {
-    return coField.ref(schema);
+    return cacheSchemaField(schema, coField.ref(schema));
   } else if (isCoValueSchema(schema)) {
     if (schema.builtin === "CoOptional") {
-      return coField.ref(schema.getCoValueClass(), {
-        optional: true,
-      });
+      return cacheSchemaField(
+        schema,
+        coField.ref(schema.getCoValueClass(), {
+          optional: true,
+        }),
+      );
     }
-    return coField.ref(schema.getCoValueClass());
+    return cacheSchemaField(schema, coField.ref(schema.getCoValueClass()));
   } else {
     if ("_zod" in schema) {
       const zodSchemaDef = schema._zod.def;
@@ -90,29 +107,35 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
         // Primitive coField types support null and undefined as values,
         // so we can just return the inner type here and rely on support
         // for null/undefined at the type level
-        return coFieldDef;
+        return cacheSchemaField(schema, coFieldDef);
       } else if (zodSchemaDef.type === "string") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "number") {
-        return coField.number;
+        return cacheSchemaField(schema, coField.number);
       } else if (zodSchemaDef.type === "boolean") {
-        return coField.boolean;
+        return cacheSchemaField(schema, coField.boolean);
       } else if (zodSchemaDef.type === "null") {
-        return coField.null;
+        return cacheSchemaField(schema, coField.null);
       } else if (zodSchemaDef.type === "enum") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "readonly") {
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodReadonly).def.innerType as SchemaField,
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            (schema as unknown as ZodReadonly).def.innerType as SchemaField,
+          ),
         );
       } else if (zodSchemaDef.type === "date") {
-        return coField.optional.Date;
+        return cacheSchemaField(schema, coField.optional.Date);
       } else if (zodSchemaDef.type === "template_literal") {
-        return coField.string;
+        return cacheSchemaField(schema, coField.string);
       } else if (zodSchemaDef.type === "lazy") {
         // Mostly to support z.json()
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodLazy).unwrap() as SchemaField,
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            (schema as unknown as ZodLazy).unwrap() as SchemaField,
+          ),
         );
       } else if (
         zodSchemaDef.type === "default" ||
@@ -122,9 +145,12 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
           "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
         );
 
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodDefault | ZodCatch).def
-            .innerType as SchemaField,
+        return cacheSchemaField(
+          schema,
+          schemaFieldToCoFieldDef(
+            (schema as unknown as ZodDefault | ZodCatch).def
+              .innerType as SchemaField,
+          ),
         );
       } else if (zodSchemaDef.type === "literal") {
         if (
@@ -140,11 +166,14 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
         ) {
           throw new Error("z.literal() with bigint is not supported");
         }
-        return coField.literal(
-          ...(zodSchemaDef.values as Exclude<
-            (typeof zodSchemaDef.values)[number],
-            undefined | null | bigint
-          >[]),
+        return cacheSchemaField(
+          schema,
+          coField.literal(
+            ...(zodSchemaDef.values as Exclude<
+              (typeof zodSchemaDef.values)[number],
+              undefined | null | bigint
+            >[]),
+          ),
         );
       } else if (
         zodSchemaDef.type === "object" ||
@@ -153,10 +182,10 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
         zodSchemaDef.type === "tuple" ||
         zodSchemaDef.type === "intersection"
       ) {
-        return coField.json();
+        return cacheSchemaField(schema, coField.json());
       } else if (zodSchemaDef.type === "union") {
         if (isUnionOfPrimitivesDeeply(schema)) {
-          return coField.json();
+          return cacheSchemaField(schema, coField.json());
         } else {
           throw new Error(
             "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead.",
@@ -183,8 +212,11 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
           throw error;
         }
 
-        return makeCodecCoField(
-          schema as z.core.$ZodCodec<z.core.$ZodType, z.core.$ZodType>,
+        return cacheSchemaField(
+          schema,
+          makeCodecCoField(
+            schema as z.core.$ZodCodec<z.core.$ZodType, z.core.$ZodType>,
+          ),
         );
       } else {
         throw new Error(