jazz-tools 0.19.0 → 0.19.1

package/src/tools/coValues/schemaUnion.ts

@@ -11,6 +11,8 @@ import {
   Group,
   ID,
   MaybeLoaded,
+  RefsToResolve,
+  RefsToResolveStrict,
   Resolved,
   Simplify,
   SubscribeListenerOptions,
@@ -150,18 +152,17 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
   /**
    * Load a `SchemaUnion` with a given ID, as a given account.
    *
-   * Note: The `resolve` option is not supported for `SchemaUnion`s due to https://github.com/garden-co/jazz/issues/2639
-   *
    * @category Subscription & Loading
    */
-  static load<M extends SchemaUnion>(
+  static load<M extends SchemaUnion, const R extends RefsToResolve<M> = true>(
     this: CoValueClass<M>,
     id: ID<M>,
     options?: {
+      resolve?: RefsToResolveStrict<M, R>;
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
     },
-  ): Promise<MaybeLoaded<Resolved<M, true>>> {
+  ): Promise<MaybeLoaded<Resolved<M, R>>> {
     return loadCoValueWithoutMe(this, id, options);
   }
 
@@ -174,27 +175,31 @@ export abstract class SchemaUnion extends CoValueBase implements CoValue {
    *
    * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
    *
-   * Note: The `resolve` option is not supported for `SchemaUnion`s due to https://github.com/garden-co/jazz/issues/2639
-   *
    * @category Subscription & Loading
    */
-  static subscribe<M extends SchemaUnion>(
+  static subscribe<
+    M extends SchemaUnion,
+    const R extends RefsToResolve<M> = true,
+  >(
     this: CoValueClass<M>,
     id: ID<M>,
-    listener: (value: Resolved<M, true>, unsubscribe: () => void) => void,
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
   ): () => void;
-  static subscribe<M extends SchemaUnion>(
+  static subscribe<
+    M extends SchemaUnion,
+    const R extends RefsToResolve<M> = true,
+  >(
     this: CoValueClass<M>,
     id: ID<M>,
-    options: SubscribeListenerOptions<M, true>,
-    listener: (value: Resolved<M, true>, unsubscribe: () => void) => void,
+    options: SubscribeListenerOptions<M, R>,
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
   ): () => void;
-  static subscribe<M extends SchemaUnion>(
+  static subscribe<M extends SchemaUnion, const R extends RefsToResolve<M>>(
     this: CoValueClass<M>,
     id: ID<M>,
-    ...args: SubscribeRestArgs<M, true>
+    ...args: SubscribeRestArgs<M, R>
   ): () => void {
     const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToCoValueWithoutMe<M, true>(this, id, options, listener);
+    return subscribeToCoValueWithoutMe<M, R>(this, id, options, listener);
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts

@@ -6,6 +6,8 @@ import {
   InstanceOfSchema,
   InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded,
   MaybeLoaded,
+  RefsToResolve,
+  RefsToResolveStrict,
   Resolved,
   SchemaUnion,
   SchemaUnionConcreteSubclass,
@@ -14,7 +16,8 @@ import {
 } from "../../../internal.js";
 import { z } from "../zodReExport.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
-import { CoreCoValueSchema } from "./CoValueSchema.js";
+import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
+import { withSchemaResolveQuery } from "../../schemaUtils.js";
 
 export interface DiscriminableCoValueSchemaDefinition {
   discriminatorMap: z.core.$ZodDiscriminatedUnionInternals["propValues"];
@@ -44,12 +47,19 @@ export interface CoreCoDiscriminatedUnionSchema<
 }
 export class CoDiscriminatedUnionSchema<
   Options extends DiscriminableCoValueSchemas,
+  DefaultResolveQuery extends CoreResolveQuery = true,
 > implements CoreCoDiscriminatedUnionSchema<Options>
 {
   readonly collaborative = true as const;
   readonly builtin = "CoDiscriminatedUnion" as const;
   readonly getDefinition: () => CoDiscriminatedUnionSchemaDefinition<Options>;
-  readonly resolveQuery = true as const;
+
+  /**
+   * Default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   * @default true
+   */
+  resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
   constructor(
     coreSchema: CoreCoDiscriminatedUnionSchema<Options>,
@@ -60,9 +70,18 @@ export class CoDiscriminatedUnionSchema<
     this.getDefinition = coreSchema.getDefinition;
   }
 
-  load(
+  load<
+    const R extends RefsToResolve<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
+      // @ts-expect-error
+    > = DefaultResolveQuery,
+  >(
     id: string,
     options?: {
+      resolve?: RefsToResolveStrict<
+        CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+        R
+      >;
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
       unstable_branch?: BranchDefinition;
@@ -71,29 +90,42 @@ export class CoDiscriminatedUnionSchema<
     MaybeLoaded<
       Resolved<
         CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
-        true
+        R
       >
     >
   > {
-    return this.coValueClass.load(id, options) as any;
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    ) as any;
   }
 
-  subscribe(
+  subscribe<
+    const R extends RefsToResolve<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
+      // @ts-expect-error
+    > = DefaultResolveQuery,
+  >(
     id: string,
     options: SubscribeListenerOptions<
       CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
-      true
+      R
     >,
     listener: (
       value: Resolved<
         CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
-        true
+        R
       >,
       unsubscribe: () => void,
     ) => void,
   ): () => void {
     // @ts-expect-error
-    return this.coValueClass.subscribe(id, options, listener);
+    return this.coValueClass.subscribe(
+      id,
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener,
+    );
   }
 
   getCoValueClass(): SchemaUnionConcreteSubclass<
@@ -105,6 +137,34 @@ export class CoDiscriminatedUnionSchema<
   optional(): CoOptionalSchema<this> {
     return coOptionalDefiner(this);
   }
+
+  /**
+   * Adds a default resolve query to be used when loading instances of this schema.
+   * This resolve query will be used when no resolve query is provided to the load method.
+   */
+  resolved<
+    const R extends RefsToResolve<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
+    > = true,
+  >(
+    resolveQuery: RefsToResolveStrict<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+      R
+    >,
+  ): CoDiscriminatedUnionSchema<Options, R> {
+    const definition = this.getDefinition();
+    const coreSchema: CoreCoDiscriminatedUnionSchema<Options> =
+      createCoreCoDiscriminatedUnionSchema(
+        definition.discriminator,
+        definition.options,
+      );
+    const copy = new CoDiscriminatedUnionSchema<Options, R>(
+      coreSchema,
+      this.coValueClass,
+    );
+    copy.resolveQuery = resolveQuery as R;
+    return copy;
+  }
 }
 
 export function createCoreCoDiscriminatedUnionSchema<

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

@@ -7,6 +7,7 @@ import {
   DiscriminableCoValueSchemas,
   DiscriminableCoreCoValueSchema,
   SchemaUnionDiscriminator,
+  coField,
 } from "../../internal.js";
 import {
   hydrateCoreCoValueSchema,
@@ -59,13 +60,23 @@ export function schemaUnionDiscriminatorFor(
     const determineSchema: SchemaUnionDiscriminator<CoMap> = (
       discriminable,
     ) => {
+      // collect all keys of nested CoValues
+      const allNestedRefKeys = new Set<string>();
+      for (const option of availableOptions) {
+        const coMapShape = (option as CoreCoMapSchema).getDefinition().shape;
+        for (const [key, value] of Object.entries(coMapShape)) {
+          if (isAnyCoValueSchema(value)) {
+            allNestedRefKeys.add(key);
+          }
+        }
+      }
+
       for (const option of availableOptions) {
         let match = true;
+        const optionDef = (option as CoreCoMapSchema).getDefinition();
 
         for (const key of Object.keys(discriminatorMap)) {
-          const discriminatorDef = (option as CoreCoMapSchema).getDefinition()
-            .shape[key];
-
+          const discriminatorDef = optionDef.shape[key];
           const discriminatorValue = discriminable.get(key);
 
           if (discriminatorValue && typeof discriminatorValue === "object") {
@@ -95,7 +106,27 @@ export function schemaUnionDiscriminatorFor(
 
         if (match) {
           const coValueSchema = hydrateCoreCoValueSchema(option as any);
-          return coValueSchema.getCoValueClass() as typeof CoMap;
+          const coValueClass = coValueSchema.getCoValueClass() as typeof CoMap;
+
+          const dummyFieldNames = allNestedRefKeys
+            .keys()
+            .filter((key) => !optionDef.shape[key])
+            .toArray();
+
+          if (dummyFieldNames.length === 0) {
+            return coValueClass;
+          }
+
+          // inject dummy fields
+          return class extends coValueClass {
+            constructor(...args: ConstructorParameters<typeof coValueClass>) {
+              super(...args);
+
+              for (const key of dummyFieldNames) {
+                (this as any)[key] = coField.null;
+              }
+            }
+          };
         }
       }
 

package/src/tools/subscribe/SubscriptionScope.ts

@@ -49,6 +49,7 @@ export class SubscriptionScope<D extends CoValue> {
   autoloadedKeys = new Set<string>();
   skipInvalidKeys = new Set<string>();
   totalValidTransactions = 0;
+  version = 0;
   migrated = false;
   migrating = false;
   closed = false;
@@ -172,9 +173,7 @@ export class SubscriptionScope<D extends CoValue> {
     } else {
       const hasChanged =
         update.totalValidTransactions !== this.totalValidTransactions ||
-        // Checking the identity of the raw value makes us cover the cases where the group
-        // has been updated and the coValues that don't update the totalValidTransactions value (e.g. FileStream)
-        this.value.value.$jazz.raw !== update;
+        update.version !== this.version;
 
       if (this.loadChildren()) {
         this.updateValue(createCoValue(this.schema, update, this));
@@ -184,6 +183,7 @@ export class SubscriptionScope<D extends CoValue> {
     }
 
     this.totalValidTransactions = update.totalValidTransactions;
+    this.version = update.version;
 
     this.silenceUpdates = false;
     this.triggerUpdate();
@@ -594,17 +594,6 @@ export class SubscriptionScope<D extends CoValue> {
     const descriptor = map.$jazz.getDescriptor(key);
 
     if (!descriptor) {
-      this.childErrors.set(
-        key,
-        new JazzError(undefined, CoValueLoadingState.UNAVAILABLE, [
-          {
-            code: "validationError",
-            message: `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
-            params: {},
-            path: [key],
-          },
-        ]),
-      );
       return undefined;
     }