jazz-tools 0.18.38 → 0.19.0

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>>;

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

@@ -4,6 +4,7 @@ import {
   CoList,
   Group,
   ID,
+  MaybeLoaded,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -15,17 +16,27 @@ import { CoValueUniqueness } from "cojson";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoListSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
-import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded.js";
 import { AnyZodOrCoValueSchema } from "../zodSchema.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
-import { CoreCoValueSchema } from "./CoValueSchema.js";
+import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
+import { withSchemaResolveQuery } from "../../schemaUtils.js";
 
-export class CoListSchema<T extends AnyZodOrCoValueSchema>
-  implements CoreCoListSchema<T>
+export class CoListSchema<
+  T extends AnyZodOrCoValueSchema,
+  DefaultResolveQuery extends CoreResolveQuery = true,
+> implements CoreCoListSchema<T>
 {
   collaborative = true as const;
   builtin = "CoList" 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 CoList,
@@ -55,43 +66,63 @@ export class CoListSchema<T extends AnyZodOrCoValueSchema>
     return this.coValueClass.create(items as any, options) as CoListInstance<T>;
   }
 
-  load<const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true>(
+  load<
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
+  >(
     id: string,
     options?: {
-      resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
+      resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
     },
-  ): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null> {
+  ): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<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<CoListInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
   >(
     id: string,
-    options?: {
-      resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
+    options: {
+      resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<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<
-    const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
   >(
     id: string,
-    options: SubscribeListenerOptions<CoListInstanceCoValuesNullable<T>, R>,
+    options: SubscribeListenerOptions<CoListInstanceCoValuesMaybeLoaded<T>, R>,
     listener: (
-      value: Resolved<CoListInstanceCoValuesNullable<T>, R>,
+      value: Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>,
       unsubscribe: () => void,
     ) => void,
   ): () => void {
-    return this.coValueClass.subscribe(id, options, listener);
+    return this.coValueClass.subscribe(
+      id,
+      withSchemaResolveQuery(options, this.resolveQuery),
+      listener,
+    );
   }
 
   getCoValueClass(): typeof CoList {
@@ -103,39 +134,65 @@ export class CoListSchema<T extends AnyZodOrCoValueSchema>
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
     as?: Account | Group | AnonymousJazzAgent,
-  ): ID<CoListInstanceCoValuesNullable<T>> {
+  ): ID<CoListInstanceCoValuesMaybeLoaded<T>> {
     return this.coValueClass.findUnique(unique, ownerID, as);
   }
 
   upsertUnique<
-    const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
   >(options: {
     value: CoListSchemaInit<T>;
     unique: CoValueUniqueness["uniqueness"];
     owner: Account | Group;
-    resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
-  }): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null> {
+    resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
+  }): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
-    return this.coValueClass.upsertUnique(options);
+    return this.coValueClass.upsertUnique(
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
   }
 
   loadUnique<
-    const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
   >(
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
     options?: {
-      resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
+      resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null> {
+  ): Promise<MaybeLoaded<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error
-    return this.coValueClass.loadUnique(unique, ownerID, options);
+    return this.coValueClass.loadUnique(
+      unique,
+      ownerID,
+      // @ts-expect-error
+      withSchemaResolveQuery(options, this.resolveQuery),
+    );
   }
 
   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<CoListInstanceCoValuesMaybeLoaded<T>> = true,
+  >(
+    resolveQuery: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>,
+  ): CoListSchema<T, R> {
+    const copy = new CoListSchema<T, R>(this.element, this.coValueClass);
+    copy.resolveQuery = resolveQuery as R;
+    return copy;
+  }
 }
 
 export function createCoreCoListSchema<T extends AnyZodOrCoValueSchema>(
@@ -145,6 +202,7 @@ export function createCoreCoListSchema<T extends AnyZodOrCoValueSchema>(
     collaborative: true as const,
     builtin: "CoList" as const,
     element,
+    resolveQuery: true as const,
   };
 }
 
@@ -160,5 +218,5 @@ export type CoListInstance<T extends AnyZodOrCoValueSchema> = CoList<
   InstanceOrPrimitiveOfSchema<T>
 >;
 
-export type CoListInstanceCoValuesNullable<T extends AnyZodOrCoValueSchema> =
-  CoList<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>;
+export type CoListInstanceCoValuesMaybeLoaded<T extends AnyZodOrCoValueSchema> =
+  CoList<InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded<T>>;