jazz-tools 0.19.2 → 0.19.4

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(

package/src/tools/implementation/zodSchema/unionUtils.ts

@@ -108,10 +108,9 @@ export function schemaUnionDiscriminatorFor(
           const coValueSchema = hydrateCoreCoValueSchema(option as any);
           const coValueClass = coValueSchema.getCoValueClass() as typeof CoMap;
 
-          const dummyFieldNames = allNestedRefKeys
-            .keys()
-            .filter((key) => !optionDef.shape[key])
-            .toArray();
+          const dummyFieldNames = Array.from(allNestedRefKeys).filter(
+            (key) => !optionDef.shape[key],
+          );
 
           if (dummyFieldNames.length === 0) {
             return coValueClass;

package/src/tools/subscribe/SubscriptionScope.ts

@@ -6,6 +6,7 @@ import {
   type CoValue,
   type ID,
   MaybeLoaded,
+  NotLoaded,
   type RefEncoded,
   type RefsToResolve,
   TypeSym,
@@ -283,7 +284,43 @@ export class SubscriptionScope<D extends CoValue> {
     return this.pendingLoadedChildren.size === 0;
   }
 
-  getCurrentValue(): D | NotLoadedCoValueState {
+  unloadedValue: NotLoaded<D> | undefined;
+
+  private getUnloadedValue(reason: NotLoadedCoValueState): NotLoaded<D> {
+    if (this.unloadedValue?.$jazz.loadingState === reason) {
+      return this.unloadedValue;
+    }
+
+    const unloadedValue: NotLoaded<D> = {
+      $jazz: {
+        id: this.id,
+        loadingState: reason,
+        // @ts-expect-error - This is a private property
+        _subscriptionScope: this,
+      },
+      $isLoaded: false,
+    };
+
+    this.unloadedValue = unloadedValue;
+
+    return unloadedValue;
+  }
+
+  getCurrentValue(): MaybeLoaded<D> {
+    const rawValue = this.getCurrentRawValue();
+
+    if (
+      rawValue === CoValueLoadingState.UNAUTHORIZED ||
+      rawValue === CoValueLoadingState.UNAVAILABLE ||
+      rawValue === CoValueLoadingState.LOADING
+    ) {
+      return this.getUnloadedValue(rawValue);
+    }
+
+    return rawValue;
+  }
+
+  getCurrentRawValue(): D | NotLoadedCoValueState {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
@@ -406,7 +443,7 @@ export class SubscriptionScope<D extends CoValue> {
     this.subscription.pullValue();
 
     // Check if the value is now available
-    const value = this.getCurrentValue();
+    const value = this.getCurrentRawValue();
 
     // If the value is available, trigger the listener
     if (typeof value !== "string") {
@@ -590,6 +627,12 @@ export class SubscriptionScope<D extends CoValue> {
       return undefined;
     }
 
+    // Check if $onError: "catch" is specified for this key
+    const skipInvalid = typeof depth === "object" && depth.$onError === "catch";
+    if (skipInvalid) {
+      this.skipInvalidKeys.add(key);
+    }
+
     const id = map.$jazz.raw.get(key) as string | undefined;
     const descriptor = map.$jazz.getDescriptor(key);
 

package/src/tools/subscribe/index.ts

@@ -1,4 +1,9 @@
-import type { CoValue, CoValueClass, RefEncoded } from "../internal.js";
+import type {
+  CoValue,
+  CoValueClass,
+  MaybeLoaded,
+  RefEncoded,
+} from "../internal.js";
 import { createUnloadedCoValue } from "../internal.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
 import { CoValueLoadingState } from "./types.js";
@@ -56,16 +61,22 @@ export function accessChildByKey<D extends CoValue>(
     );
   }
 
+  // TODO: this doesn't check the subscription tree loading state
+  // so if one of the children is loading, it will return the loading state
+  // instead of the latest loaded state
   const value = subscriptionScope.childValues.get(childId);
 
   if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
-  } else {
-    return createUnloadedCoValue(
-      childId,
-      value?.type ?? CoValueLoadingState.LOADING,
-    );
   }
+
+  const childNode = subscriptionScope.childNodes.get(childId);
+
+  if (!childNode) {
+    return createUnloadedCoValue(childId, CoValueLoadingState.UNAVAILABLE);
+  }
+
+  return childNode.getCurrentValue();
 }
 
 /**
@@ -77,9 +88,9 @@ export function accessChildByKey<D extends CoValue>(
  * Used for refs that never change (e.g. CoFeed entries, CoMap edits)
  */
 export function accessChildById<D extends CoValue>(
-  parent: D,
+  parent: CoValue,
   childId: string,
-  schema: RefEncoded<CoValue>,
+  schema: RefEncoded<D>,
 ) {
   const subscriptionScope = getSubscriptionScope(parent);
 
@@ -87,12 +98,16 @@ export function accessChildById<D extends CoValue>(
 
   const value = subscriptionScope.childValues.get(childId);
 
+  // TODO: this doesn't check the subscription tree loading state
   if (value?.type === CoValueLoadingState.LOADED) {
     return value.value;
-  } else {
-    return createUnloadedCoValue(
-      childId,
-      value?.type ?? CoValueLoadingState.LOADING,
-    );
   }
+
+  const childNode = subscriptionScope.childNodes.get(childId);
+
+  if (!childNode) {
+    return createUnloadedCoValue<D>(childId, CoValueLoadingState.UNAVAILABLE);
+  }
+
+  return childNode.getCurrentValue() as MaybeLoaded<D>;
 }

package/src/tools/subscribe/types.ts

@@ -29,10 +29,13 @@ export const CoValueLoadingState = {
 export type CoValueLoadingState =
   (typeof CoValueLoadingState)[keyof typeof CoValueLoadingState];
 
+export type CoValueErrorState =
+  | typeof CoValueLoadingState.UNAVAILABLE
+  | typeof CoValueLoadingState.UNAUTHORIZED;
+
 export type NotLoadedCoValueState =
   | typeof CoValueLoadingState.LOADING
-  | typeof CoValueLoadingState.UNAUTHORIZED
-  | typeof CoValueLoadingState.UNAVAILABLE;
+  | CoValueErrorState;
 
 export type SubscriptionValue<D extends CoValue, R extends RefsToResolve<D>> =
   | {