jazz-tools 0.15.16 → 0.16.0

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

@@ -2,28 +2,42 @@ import {
   Account,
   CoList,
   Group,
+  NotNull,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
+  Simplify,
   SubscribeListenerOptions,
+  coOptionalDefiner,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
-import { z } from "../zodReExport.js";
-import { WithHelpers } from "../zodSchema.js";
+import { AnyZodOrCoValueSchema } from "../zodSchema.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-type CoListInit<T extends z.core.$ZodType> = Array<
-  T extends z.core.$ZodOptional<any>
-    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
-    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>
+type CoListInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  Array<NotNull<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>>
 >;
 
-export type CoListSchema<T extends z.core.$ZodType> = AnyCoListSchema<T> & {
-  create: (
+export class CoListSchema<T extends AnyZodOrCoValueSchema>
+  implements CoreCoListSchema<T>
+{
+  collaborative = true as const;
+  builtin = "CoList" as const;
+
+  constructor(
+    public element: T,
+    private coValueClass: typeof CoList,
+  ) {}
+
+  create(
     items: CoListInit<T>,
     options?: { owner: Account | Group } | Account | Group,
-  ) => CoList<InstanceOrPrimitiveOfSchema<T>>;
+  ): CoListInstance<T> {
+    return this.coValueClass.create(items, options) as CoListInstance<T>;
+  }
 
   load<const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true>(
     id: string,
@@ -31,7 +45,10 @@ export type CoListSchema<T extends z.core.$ZodType> = AnyCoListSchema<T> & {
       resolve?: RefsToResolveStrict<CoListInstanceCoValuesNullable<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null>;
+  ): Promise<Resolved<CoListInstanceCoValuesNullable<T>, R> | null> {
+    // @ts-expect-error
+    return this.coValueClass.load(id, options);
+  }
 
   subscribe<
     const R extends RefsToResolve<CoListInstanceCoValuesNullable<T>> = true,
@@ -42,49 +59,40 @@ export type CoListSchema<T extends z.core.$ZodType> = AnyCoListSchema<T> & {
       value: Resolved<CoListInstanceCoValuesNullable<T>, R>,
       unsubscribe: () => void,
     ) => void,
-  ): () => void;
+  ): () => void {
+    return this.coValueClass.subscribe(id, options, listener);
+  }
 
-  /** @deprecated Define your helper methods separately, in standalone functions. */
-  withHelpers<S extends z.core.$ZodType, T extends object>(
-    this: S,
-    helpers: (Self: S) => T,
-  ): WithHelpers<S, T>;
+  getCoValueClass(): typeof CoList {
+    return this.coValueClass;
+  }
 
-  getCoValueClass: () => typeof CoList;
-};
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
+}
 
-export function enrichCoListSchema<T extends z.core.$ZodType>(
-  schema: AnyCoListSchema<T>,
-  coValueClass: typeof CoList,
-): CoListSchema<T> {
-  return Object.assign(schema, {
-    create: (...args: [any, ...any[]]) => {
-      return coValueClass.create(...args);
-    },
-    load: (...args: [any, ...any[]]) => {
-      return coValueClass.load(...args);
-    },
-    subscribe: (...args: [any, ...any[]]) => {
-      // @ts-expect-error
-      return coValueClass.subscribe(...args);
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    getCoValueClass: () => {
-      return coValueClass;
-    },
-  }) as unknown as CoListSchema<T>;
+export function createCoreCoListSchema<T extends AnyZodOrCoValueSchema>(
+  element: T,
+): CoreCoListSchema<T> {
+  return {
+    collaborative: true as const,
+    builtin: "CoList" as const,
+    element,
+  };
 }
 
 // less precise version to avoid circularity issues and allow matching against
-export type AnyCoListSchema<T extends z.core.$ZodType = z.core.$ZodType> =
-  z.core.$ZodArray<T> & { collaborative: true };
+export interface CoreCoListSchema<
+  T extends AnyZodOrCoValueSchema = AnyZodOrCoValueSchema,
+> extends CoreCoValueSchema {
+  builtin: "CoList";
+  element: T;
+}
 
-export type CoListInstance<T extends z.core.$ZodType> = CoList<
+export type CoListInstance<T extends AnyZodOrCoValueSchema> = CoList<
   InstanceOrPrimitiveOfSchema<T>
 >;
 
-export type CoListInstanceCoValuesNullable<T extends z.core.$ZodType> = CoList<
-  InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
->;
+export type CoListInstanceCoValuesNullable<T extends AnyZodOrCoValueSchema> =
+  CoList<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>;

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

@@ -2,160 +2,193 @@ import { CoValueUniqueness } from "cojson";
 import {
   Account,
   CoMap,
+  DiscriminableCoValueSchemaDefinition,
+  DiscriminableCoreCoValueSchema,
   Group,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
   Simplify,
   SubscribeListenerOptions,
-  zodSchemaToCoSchema,
+  coOptionalDefiner,
+  hydrateCoreCoValueSchema,
+  isAnyCoValueSchema,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { removeGetters } from "../../schemaUtils.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
-import { WithHelpers } from "../zodSchema.js";
+import { AnyZodOrCoValueSchema } from "../zodSchema.js";
+import { CoOptionalSchema, CoreCoOptionalSchema } from "./CoOptionalSchema.js";
 
-export type CoMapSchema<
+export interface CoMapSchema<
   Shape extends z.core.$ZodLooseShape,
-  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
   Owner extends Account | Group = Account | Group,
-> = AnyCoMapSchema<Shape, Config> &
-  z.$ZodTypeDiscriminable & {
-    create: (
-      init: Simplify<CoMapInitZod<Shape>>,
-      options?:
-        | {
-            owner: Owner;
-            unique?: CoValueUniqueness["uniqueness"];
-          }
-        | Owner,
-    ) => (Shape extends Record<string, never>
+> extends CoreCoMapSchema<Shape, CatchAll> {
+  create: (
+    init: Simplify<CoMapInitZod<Shape>>,
+    options?:
+      | {
+          owner: Owner;
+          unique?: CoValueUniqueness["uniqueness"];
+        }
+      | Owner,
+  ) => (Shape extends Record<string, never>
+    ? {}
+    : {
+        -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+      }) &
+    (unknown extends CatchAll
       ? {}
       : {
-          -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-            Shape[key]
-          >;
+          // @ts-expect-error
+          [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
         }) &
-      (unknown extends Config["out"][string]
-        ? {}
-        : {
-            [key: string]: Config["out"][string];
-          }) &
-      CoMap;
-
-    load<
-      const R extends RefsToResolve<
-        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
-      > = true,
-    >(
-      id: string,
-      options?: {
-        resolve?: RefsToResolveStrict<
-          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-          R
-        >;
-        loadAs?: Account | AnonymousJazzAgent;
-        skipRetry?: boolean;
-      },
-    ): Promise<Resolved<
+    CoMap;
+
+  load<
+    const R extends RefsToResolve<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+    > = true,
+  >(
+    id: string,
+    options?: {
+      resolve?: RefsToResolveStrict<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+        R
+      >;
+      loadAs?: Account | AnonymousJazzAgent;
+      skipRetry?: boolean;
+    },
+  ): Promise<Resolved<
+    Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+    R
+  > | null>;
+
+  subscribe<
+    const R extends RefsToResolve<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+    > = true,
+  >(
+    id: string,
+    options: SubscribeListenerOptions<
       Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
       R
-    > | null>;
-
-    subscribe<
-      const R extends RefsToResolve<
-        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
-      > = true,
-    >(
-      id: string,
-      options: SubscribeListenerOptions<
+    >,
+    listener: (
+      value: Resolved<
         Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
         R
       >,
-      listener: (
-        value: Resolved<
-          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-          R
-        >,
-        unsubscribe: () => void,
-      ) => void,
-    ): () => void;
-
-    /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
-    findUnique(
-      unique: CoValueUniqueness["uniqueness"],
-      ownerID: string,
-      as?: Account | Group | AnonymousJazzAgent,
-    ): string;
-
-    upsertUnique: <
-      const R extends RefsToResolve<
-        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
-      > = true,
-    >(options: {
-      value: Simplify<CoMapInitZod<Shape>>;
-      unique: CoValueUniqueness["uniqueness"];
-      owner: Owner;
+      unsubscribe: () => void,
+    ) => void,
+  ): () => void;
+
+  /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
+  findUnique(
+    unique: CoValueUniqueness["uniqueness"],
+    ownerID: string,
+    as?: Account | Group | AnonymousJazzAgent,
+  ): string;
+
+  upsertUnique: <
+    const R extends RefsToResolve<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+    > = true,
+  >(options: {
+    value: Simplify<CoMapInitZod<Shape>>;
+    unique: CoValueUniqueness["uniqueness"];
+    owner: Owner;
+    resolve?: RefsToResolveStrict<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+      R
+    >;
+  }) => Promise<Resolved<
+    Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+    R
+  > | null>;
+
+  loadUnique<
+    const R extends RefsToResolve<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+    > = true,
+  >(
+    unique: CoValueUniqueness["uniqueness"],
+    ownerID: string,
+    options?: {
       resolve?: RefsToResolveStrict<
         Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
         R
       >;
-    }) => Promise<Resolved<
-      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-      R
-    > | null>;
-
-    loadUnique<
-      const R extends RefsToResolve<
-        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
-      > = true,
-    >(
-      unique: CoValueUniqueness["uniqueness"],
-      ownerID: string,
-      options?: {
-        resolve?: RefsToResolveStrict<
-          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-          R
-        >;
-        loadAs?: Account | AnonymousJazzAgent;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Resolved<
+    Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+    R
+  > | null>;
+
+  catchall<T extends AnyZodOrCoValueSchema>(schema: T): CoMapSchema<Shape, T>;
+
+  withMigration(
+    migration: (
+      value: Resolved<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+        true
+      >,
+    ) => undefined,
+  ): CoMapSchema<Shape, CatchAll, Owner>;
+
+  getCoValueClass: () => typeof CoMap;
+
+  optional(): CoOptionalSchema<this>;
+}
+
+export function createCoreCoMapSchema<
+  Shape extends z.core.$ZodLooseShape,
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
+>(shape: Shape, catchAll?: CatchAll): CoreCoMapSchema<Shape, CatchAll> {
+  return {
+    collaborative: true as const,
+    builtin: "CoMap" as const,
+    shape,
+    catchAll,
+    getDefinition: () => ({
+      get shape() {
+        return shape;
       },
-    ): Promise<Resolved<
-      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-      R
-    > | null>;
-
-    catchall<T extends z.core.$ZodType>(
-      schema: T,
-    ): CoMapSchema<Shape, z.core.$catchall<T>>;
-
-    /** @deprecated Define your helper methods separately, in standalone functions. */
-    withHelpers<S extends z.core.$ZodType, T extends object>(
-      this: S,
-      helpers: (Self: S) => T,
-    ): WithHelpers<S, T>;
-
-    withMigration(
-      migration: (
-        value: Resolved<
-          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
-          true
-        >,
-      ) => undefined,
-    ): CoMapSchema<Shape, Config, Owner>;
-
-    getCoValueClass: () => typeof CoMap;
+      get catchall() {
+        return catchAll;
+      },
+      get discriminatorMap() {
+        const propValues: DiscriminableCoValueSchemaDefinition["discriminatorMap"] =
+          {};
+        // remove getters to avoid circularity issues. Getters are not used as discriminators
+        for (const key in removeGetters(shape)) {
+          if (isAnyCoValueSchema(shape[key])) {
+            // CoValues cannot be used as discriminators either
+            continue;
+          }
+          const field = shape[key]._zod;
+          if (field.values) {
+            propValues[key] ??= new Set();
+            for (const v of field.values) propValues[key].add(v);
+          }
+        }
+        return propValues;
+      },
+    }),
   };
+}
 
 export function enrichCoMapSchema<
   Shape extends z.core.$ZodLooseShape,
-  Config extends z.core.$ZodObjectConfig,
+  CatchAll extends AnyZodOrCoValueSchema | unknown,
 >(
-  schema: AnyCoMapSchema<Shape, Config>,
+  schema: CoreCoMapSchema<Shape, CatchAll>,
   coValueClass: typeof CoMap,
-): CoMapSchema<Shape, Config> {
-  // @ts-expect-error schema is actually a z.ZodObject, but we need to use z.core.$ZodObject to avoid circularity issues
-  const baseCatchall = schema.catchall;
+): CoMapSchema<Shape, CatchAll> {
   const coValueSchema = Object.assign(schema, {
     create: (...args: [any, ...any[]]) => {
       return coValueClass.create(...args);
@@ -179,16 +212,12 @@ export function enrichCoMapSchema<
       // @ts-expect-error
       return coValueClass.loadUnique(...args);
     },
-    catchall: (index: z.core.$ZodType) => {
-      const newSchema = baseCatchall(index);
-      // TODO avoid repeating this with coMapDefiner
-      const enrichedSchema = Object.assign(newSchema, {
-        collaborative: true,
-      }) as AnyCoMapSchema<Shape, Config>;
-      return zodSchemaToCoSchema(enrichedSchema);
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
+    catchall: (catchAll: AnyZodOrCoValueSchema) => {
+      const schemaWithCatchAll = createCoreCoMapSchema(
+        coValueSchema.getDefinition().shape,
+        catchAll,
+      );
+      return hydrateCoreCoValueSchema(schemaWithCatchAll);
     },
     withMigration: (migration: (value: any) => undefined) => {
       // @ts-expect-error TODO check
@@ -199,18 +228,26 @@ export function enrichCoMapSchema<
     getCoValueClass: () => {
       return coValueClass;
     },
-  }) as unknown as CoMapSchema<Shape, Config>;
+
+    optional: () => {
+      return coOptionalDefiner(coValueSchema);
+    },
+  }) as unknown as CoMapSchema<Shape, CatchAll>;
   return coValueSchema;
 }
 
 export type optionalKeys<Shape extends z.core.$ZodLooseShape> = {
-  [key in keyof Shape]: Shape[key] extends z.core.$ZodOptional<any>
+  [key in keyof Shape]: Shape[key] extends
+    | z.core.$ZodOptional<any>
+    | CoreCoOptionalSchema<any>
     ? key
     : never;
 }[keyof Shape];
 
 export type requiredKeys<Shape extends z.core.$ZodLooseShape> = {
-  [key in keyof Shape]: Shape[key] extends z.core.$ZodOptional<any>
+  [key in keyof Shape]: Shape[key] extends
+    | z.core.$ZodOptional<any>
+    | CoreCoOptionalSchema<any>
     ? never
     : key;
 }[keyof Shape];
@@ -225,11 +262,24 @@ export type CoMapInitZod<Shape extends z.core.$ZodLooseShape> = {
   >;
 } & { [key in keyof Shape]?: unknown };
 
+export interface CoMapSchemaDefinition<
+  Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
+> extends DiscriminableCoValueSchemaDefinition {
+  shape: Shape;
+  catchall?: CatchAll;
+}
+
 // less precise version to avoid circularity issues and allow matching against
-export type AnyCoMapSchema<
+export interface CoreCoMapSchema<
   Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
-  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
-> = z.core.$ZodObject<Shape, Config> & { collaborative: true };
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
+> extends DiscriminableCoreCoValueSchema {
+  builtin: "CoMap";
+  shape: Shape;
+  catchAll?: CatchAll;
+  getDefinition: () => CoMapSchemaDefinition;
+}
 
 export type CoMapInstance<Shape extends z.core.$ZodLooseShape> = {
   -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;

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

@@ -1,33 +1,35 @@
-import { isAnyCoValueSchema } from "../runtimeConverters/zodSchemaToCoSchema.js";
-import { z } from "../zodReExport.js";
-import { AnyCoSchema, CoValueSchemaFromZodSchema } from "../zodSchema.js";
+import { CoValueSchemaFromCoreSchema } from "../zodSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-export type AnyCoOptionalSchema<
-  Shape extends z.core.$ZodType = z.core.$ZodType,
-> = z.ZodOptional<Shape> & {
-  collaborative: true;
+type CoOptionalSchemaDefinition<
+  Shape extends CoreCoValueSchema = CoreCoValueSchema,
+> = {
+  innerType: Shape;
 };
 
-export type CoOptionalSchema<Shape extends z.core.$ZodType = z.core.$ZodType> =
-  AnyCoOptionalSchema<Shape> & {
-    getCoValueClass: () => CoValueSchemaFromZodSchema<AnyCoSchema>["getCoValueClass"];
-  };
-
-export function createCoOptionalSchema<T extends AnyCoSchema>(
-  schema: T,
-): CoOptionalSchema<T> {
-  return Object.assign(z.optional(schema), {
-    collaborative: true,
-    getCoValueClass: () => {
-      return (
-        schema as CoValueSchemaFromZodSchema<AnyCoSchema>
-      ).getCoValueClass();
-    },
-  }) as unknown as CoOptionalSchema<T>;
+export interface CoreCoOptionalSchema<
+  Shape extends CoreCoValueSchema = CoreCoValueSchema,
+> extends CoreCoValueSchema {
+  builtin: "CoOptional";
+  innerType: Shape;
+  getDefinition: () => CoOptionalSchemaDefinition<Shape>;
 }
 
-export function isAnyCoOptionalSchema(
-  schema: z.core.$ZodType,
-): schema is CoOptionalSchema<z.core.$ZodType> {
-  return isAnyCoValueSchema(schema) && schema._zod.def.type === "optional";
+export class CoOptionalSchema<
+  Shape extends CoreCoValueSchema = CoreCoValueSchema,
+> implements CoreCoOptionalSchema<Shape>
+{
+  readonly collaborative = true as const;
+  readonly builtin = "CoOptional" as const;
+  readonly getDefinition = () => ({
+    innerType: this.innerType,
+  });
+
+  constructor(public readonly innerType: Shape) {}
+
+  getCoValueClass(): ReturnType<
+    CoValueSchemaFromCoreSchema<Shape>["getCoValueClass"]
+  > {
+    return (this.innerType as any).getCoValueClass();
+  }
 }