jazz-tools 0.18.38 → 0.19.1

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

@@ -2,14 +2,20 @@ import {
   Account,
   AccountCreationProps,
   BranchDefinition,
+  CoMapSchemaDefinition,
   coOptionalDefiner,
   Group,
+  MaybeLoaded,
   RefsToResolveStrict,
+  RefsToResolve,
+  Resolved,
   Simplify,
+  SubscribeListenerOptions,
+  unstable_mergeBranchWithResolve,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
-import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded.js";
 import { z } from "../zodReExport.js";
 import { AnyZodOrCoValueSchema, Loaded, ResolveQuery } from "../zodSchema.js";
 import {
@@ -17,6 +23,9 @@ import {
   CoreCoMapSchema,
   createCoreCoMapSchema,
 } from "./CoMapSchema.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreResolveQuery } from "./CoValueSchema.js";
+import { withSchemaResolveQuery } from "../../schemaUtils.js";
 
 export type BaseProfileShape = {
   name: z.core.$ZodString<string>;
@@ -34,60 +43,151 @@ export type DefaultAccountShape = {
   root: CoMapSchema<{}>;
 };
 
-export interface AccountSchema<
+export class AccountSchema<
   Shape extends BaseAccountShape = DefaultAccountShape,
-> extends CoreAccountSchema<Shape>,
-    Omit<
-      CoMapSchema<Shape>,
-      | "builtin"
-      | "getDefinition"
-      | "create"
-      | "load"
-      | "withMigration"
-      | "unstable_merge"
-      | "getCoValueClass"
-    > {
-  builtin: "Account";
-
-  create: (
+  DefaultResolveQuery extends CoreResolveQuery = true,
+> implements CoreAccountSchema<Shape>
+{
+  collaborative = true as const;
+  builtin = "Account" as const;
+  shape: Shape;
+  getDefinition: () => CoMapSchemaDefinition;
+
+  /**
+   * 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: CoreAccountSchema<Shape>,
+    private coValueClass: typeof Account,
+  ) {
+    this.shape = coreSchema.shape;
+    this.getDefinition = coreSchema.getDefinition;
+  }
+
+  create(
     options: Simplify<Parameters<(typeof Account)["create"]>[0]>,
-  ) => Promise<AccountInstance<Shape>>;
-
-  load: <R extends ResolveQuery<AccountSchema<Shape>>>(
+  ): Promise<AccountInstance<Shape>> {
+    // @ts-expect-error
+    return this.coValueClass.create(options);
+  }
+
+  load<
+    // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    const R extends ResolveQuery<AccountSchema<Shape>> = DefaultResolveQuery,
+  >(
     id: string,
     options?: {
       loadAs?: Account | AnonymousJazzAgent;
       resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
     },
-  ) => Promise<Loaded<AccountSchema<Shape>, R> | null>;
+  ): Promise<MaybeLoaded<Loaded<AccountSchema<Shape>, R>>> {
+    // @ts-expect-error
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
+  }
 
   /** @internal */
-  createAs: (
+  createAs(
     as: Account,
     options: {
-      creationProps?: { name: string };
+      creationProps: { name: string };
     },
-  ) => Promise<AccountInstance<Shape>>;
-
-  unstable_merge: <R extends ResolveQuery<AccountSchema<Shape>>>(
+  ): Promise<AccountInstance<Shape>> {
+    // @ts-expect-error
+    return this.coValueClass.createAs(as, options);
+  }
+
+  unstable_merge<
+    // @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<AccountSchema<Shape>> = DefaultResolveQuery,
+  >(
     id: string,
-    options?: {
+    options: {
       loadAs?: Account | AnonymousJazzAgent;
       resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
       branch: BranchDefinition;
     },
-  ) => Promise<void>;
+  ): Promise<void> {
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
+  }
+
+  subscribe<
+    const R extends RefsToResolve<
+      Simplify<AccountInstance<Shape>>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
+  >(
+    id: string,
+    options: SubscribeListenerOptions<Simplify<AccountInstance<Shape>>, R>,
+    listener: (
+      value: Resolved<Simplify<AccountInstance<Shape>>, R>,
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void {
+    return this.coValueClass.subscribe(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener,
+    );
+  }
 
-  getMe: () => AccountInstanceCoValuesNullable<Shape>;
+  getMe(): Loaded<this, true> {
+    // @ts-expect-error
+    return this.coValueClass.getMe();
+  }
 
   withMigration(
     migration: (
       account: Loaded<AccountSchema<Shape>>,
       creationProps?: { name: string },
     ) => void,
-  ): AccountSchema<Shape>;
-
-  getCoValueClass: () => typeof Account;
+  ): AccountSchema<Shape, DefaultResolveQuery> {
+    (this.coValueClass.prototype as Account).migrate = async function (
+      this,
+      creationProps,
+    ) {
+      // @ts-expect-error
+      await migration(this, creationProps);
+    };
+
+    return this;
+  }
+
+  getCoValueClass(): typeof Account {
+    return this.coValueClass;
+  }
+
+  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<R extends ResolveQuery<AccountSchema<Shape>>>(
+    resolveQuery: RefsToResolveStrict<AccountSchema<Shape>, R>,
+  ): AccountSchema<Shape, R> {
+    const coreSchema: CoreAccountSchema<Shape> = createCoreAccountSchema(
+      this.shape,
+    );
+    const copy = new AccountSchema<Shape, R>(coreSchema, this.coValueClass);
+    copy.resolveQuery = resolveQuery as R;
+    return copy;
+  }
 }
 
 export function createCoreAccountSchema<Shape extends BaseAccountShape>(
@@ -99,62 +199,6 @@ export function createCoreAccountSchema<Shape extends BaseAccountShape>(
   };
 }
 
-export function enrichAccountSchema<Shape extends BaseAccountShape>(
-  schema: CoreAccountSchema<Shape>,
-  coValueClass: typeof Account,
-): AccountSchema<Shape> {
-  const enrichedSchema = Object.assign(schema, {
-    create: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.create(...args);
-    },
-    createAs: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.createAs(...args);
-    },
-    getMe: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.getMe(...args);
-    },
-    load: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.subscribe(...args);
-    },
-    fromRaw: (...args: any[]) => {
-      // @ts-expect-error
-      return coValueClass.fromRaw(...args);
-    },
-    unstable_merge: (...args: any[]) => {
-      // @ts-expect-error
-      return unstable_mergeBranchWithResolve(coValueClass, ...args);
-    },
-    withMigration: (
-      migration: (
-        value: any,
-        creationProps?: AccountCreationProps,
-      ) => void | Promise<void>,
-    ) => {
-      (coValueClass.prototype as Account).migrate = async function (
-        this,
-        creationProps,
-      ) {
-        await migration(this, creationProps);
-      };
-
-      return enrichedSchema;
-    },
-    getCoValueClass: () => {
-      return coValueClass;
-    },
-    optional: () => coOptionalDefiner(enrichedSchema),
-  }) as unknown as AccountSchema<Shape>;
-  return enrichedSchema;
-}
-
 export type DefaultProfileShape = {
   name: z.core.$ZodString<string>;
   inbox: z.core.$ZodOptional<z.core.$ZodString>;
@@ -176,11 +220,3 @@ export interface CoreAccountSchema<
 export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
   readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
 } & Account;
-
-export type AccountInstanceCoValuesNullable<
-  Shape extends z.core.$ZodLooseShape,
-> = {
-  readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
-    Shape[key]
-  >;
-} & Account;

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

@@ -1,9 +1,13 @@
 import {
   Account,
   AnonymousJazzAgent,
+  LoadedAndRequired,
   BranchDefinition,
   InstanceOfSchema,
-  InstanceOrPrimitiveOfSchemaCoValuesNullable,
+  InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded,
+  MaybeLoaded,
+  RefsToResolve,
+  RefsToResolveStrict,
   Resolved,
   SchemaUnion,
   SchemaUnionConcreteSubclass,
@@ -12,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"];
@@ -42,12 +47,20 @@ 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>;
 
+  /**
+   * 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>,
     private coValueClass: SchemaUnionConcreteSubclass<
@@ -57,36 +70,62 @@ 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;
     },
-  ): Promise<Resolved<
-    CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
-    true
-  > | null> {
-    return this.coValueClass.load(id, options) as any;
+  ): Promise<
+    MaybeLoaded<
+      Resolved<
+        CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+        R
+      >
+    >
+  > {
+    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<
-      CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
-      true
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+      R
     >,
     listener: (
       value: Resolved<
-        CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
-        true
+        CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+        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<
@@ -98,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<
@@ -133,9 +200,12 @@ export function createCoreCoDiscriminatedUnionSchema<
         return schemas;
       },
     }),
+    resolveQuery: true as const,
   };
 }
 
-type CoDiscriminatedUnionInstanceCoValuesNullable<
+type CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<
   Options extends DiscriminableCoValueSchemas,
-> = NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<Options[number]>>;
+> = LoadedAndRequired<
+  InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded<Options[number]>
+>;

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

@@ -4,26 +4,38 @@ import {
   BranchDefinition,
   CoFeed,
   Group,
+  MaybeLoaded,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
   SubscribeListenerOptions,
   coOptionalDefiner,
+  parseSubscribeRestArgs,
   unstable_mergeBranchWithResolve,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoFeedSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
-import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
-import { CoreCoValueSchema } from "./CoValueSchema.js";
+import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
+import { withSchemaResolveQuery } from "../../schemaUtils.js";
 
-export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
-  implements CoreCoFeedSchema<T>
+export class CoFeedSchema<
+  T extends AnyZodOrCoValueSchema,
+  DefaultResolveQuery extends CoreResolveQuery = true,
+> implements CoreCoFeedSchema<T>
 {
   collaborative = true as const;
   builtin = "CoFeed" 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(
     public element: T,
     private coValueClass: typeof CoFeed,
@@ -45,52 +57,76 @@ export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
     return this.coValueClass.create(init as any, options) as CoFeedInstance<T>;
   }
 
-  load<const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true>(
+  load<
+    const R extends RefsToResolve<
+      CoFeedInstanceCoValuesMaybeLoaded<T>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
+  >(
     id: string,
     options?: {
-      resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesNullable<T>, R>;
+      resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
     },
-  ): Promise<Resolved<CoFeedInstanceCoValuesNullable<T>, R> | null> {
+  ): Promise<MaybeLoaded<Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
-    return this.coValueClass.load(id, options);
+    return this.coValueClass.load(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
   }
 
   unstable_merge<
-    const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoFeedInstanceCoValuesMaybeLoaded<T>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
   >(
     id: string,
-    options?: {
-      resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesNullable<T>, R>;
+    options: {
+      resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
       branch: BranchDefinition;
     },
   ): Promise<void> {
-    // @ts-expect-error
-    return unstable_mergeBranchWithResolve(this.coValueClass, id, options);
+    return unstable_mergeBranchWithResolve(
+      this.coValueClass,
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
   }
 
   subscribe(
     id: string,
     listener: (
-      value: Resolved<CoFeedInstanceCoValuesNullable<T>, true>,
+      value: Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, true>,
       unsubscribe: () => void,
     ) => void,
   ): () => void;
   subscribe<
-    const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoFeedInstanceCoValuesMaybeLoaded<T>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
   >(
     id: string,
-    options: SubscribeListenerOptions<CoFeedInstanceCoValuesNullable<T>, R>,
+    options: SubscribeListenerOptions<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
     listener: (
-      value: Resolved<CoFeedInstanceCoValuesNullable<T>, R>,
+      value: Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
       unsubscribe: () => void,
     ) => void,
   ): () => void;
-  subscribe(...args: [any, ...any[]]) {
-    // @ts-expect-error
-    return this.coValueClass.subscribe(...args);
+  subscribe(id: string, ...args: any) {
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return this.coValueClass.subscribe(
+      id,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener,
+    );
   }
 
   getCoValueClass(): typeof CoFeed {
@@ -100,6 +136,20 @@ export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
   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<CoFeedInstanceCoValuesMaybeLoaded<T>> = true,
+  >(
+    resolveQuery: RefsToResolveStrict<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
+  ): CoFeedSchema<T, R> {
+    const copy = new CoFeedSchema<T, R>(this.element, this.coValueClass);
+    copy.resolveQuery = resolveQuery as R;
+    return copy;
+  }
 }
 
 export function createCoreCoFeedSchema<T extends AnyZodOrCoValueSchema>(
@@ -109,6 +159,7 @@ export function createCoreCoFeedSchema<T extends AnyZodOrCoValueSchema>(
     collaborative: true as const,
     builtin: "CoFeed" as const,
     element,
+    resolveQuery: true as const,
   };
 }
 
@@ -124,5 +175,5 @@ export type CoFeedInstance<T extends AnyZodOrCoValueSchema> = CoFeed<
   InstanceOrPrimitiveOfSchema<T>
 >;
 
-export type CoFeedInstanceCoValuesNullable<T extends AnyZodOrCoValueSchema> =
-  CoFeed<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>;
+export type CoFeedInstanceCoValuesMaybeLoaded<T extends AnyZodOrCoValueSchema> =
+  CoFeed<InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded<T>>;