jazz-tools 0.15.16 → 0.16.0

package/src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts

@@ -0,0 +1,133 @@
+import { CoValueClass, isCoValueClass } from "../../../internal.js";
+import { coField } from "../../schema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { isUnionOfPrimitivesDeeply } from "../unionUtils.js";
+import {
+  ZodCatch,
+  ZodDefault,
+  ZodLazy,
+  ZodReadonly,
+  z,
+} from "../zodReExport.js";
+import { ZodPrimitiveSchema } from "../zodSchema.js";
+import { isCoValueSchema } from "./coValueSchemaTransformation.js";
+
+/**
+ * Types of objects that can be nested inside CoValue schema containers
+ */
+export type SchemaField =
+  // Schemas created with co.map(), co.record(), co.list(), etc.
+  | CoreCoValueSchema
+  // CoValue classes created with class syntax, or framework-provided classes like Group
+  | CoValueClass
+  | ZodPrimitiveSchema
+  | z.core.$ZodOptional<z.core.$ZodType>
+  | z.core.$ZodUnion<z.core.$ZodType[]>
+  | z.core.$ZodDiscriminatedUnion<z.core.$ZodType[]>
+  | z.core.$ZodObject<z.core.$ZodLooseShape>
+  | z.core.$ZodArray<z.core.$ZodType>
+  | z.core.$ZodTuple<z.core.$ZodType[]>
+  | z.core.$ZodReadonly<z.core.$ZodType>
+  | z.core.$ZodLazy<z.core.$ZodType>
+  | z.core.$ZodTemplateLiteral<any>
+  | z.core.$ZodLiteral<any>
+  | z.core.$ZodCatch<z.core.$ZodType>
+  | z.core.$ZodEnum<any>
+  | z.core.$ZodDefault<z.core.$ZodType>
+  | z.core.$ZodCatch<z.core.$ZodType>;
+
+export function schemaFieldToCoFieldDef(schema: SchemaField) {
+  if (isCoValueClass(schema)) {
+    return coField.ref(schema);
+  } else if (isCoValueSchema(schema)) {
+    if (schema.builtin === "CoOptional") {
+      return coField.ref(schema.getCoValueClass(), {
+        optional: true,
+      });
+    }
+    return coField.ref(schema.getCoValueClass());
+  } else {
+    if ("_zod" in schema) {
+      const zodSchemaDef = schema._zod.def;
+      if (zodSchemaDef.type === "optional") {
+        const inner = zodSchemaDef.innerType as ZodPrimitiveSchema;
+        return schemaFieldToCoFieldDef(inner);
+      } else if (zodSchemaDef.type === "string") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "number") {
+        return coField.number;
+      } else if (zodSchemaDef.type === "boolean") {
+        return coField.boolean;
+      } else if (zodSchemaDef.type === "null") {
+        return coField.null;
+      } else if (zodSchemaDef.type === "enum") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "readonly") {
+        return schemaFieldToCoFieldDef(
+          (schema as unknown as ZodReadonly).def.innerType as SchemaField,
+        );
+      } else if (zodSchemaDef.type === "date") {
+        return coField.optional.Date;
+      } else if (zodSchemaDef.type === "template_literal") {
+        return coField.string;
+      } else if (zodSchemaDef.type === "lazy") {
+        // Mostly to support z.json()
+        return schemaFieldToCoFieldDef(
+          (schema as unknown as ZodLazy).unwrap() as SchemaField,
+        );
+      } else if (
+        zodSchemaDef.type === "default" ||
+        zodSchemaDef.type === "catch"
+      ) {
+        console.warn(
+          "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,
+        );
+      } else if (zodSchemaDef.type === "literal") {
+        if (
+          zodSchemaDef.values.some((literal) => typeof literal === "undefined")
+        ) {
+          throw new Error("z.literal() with undefined is not supported");
+        }
+        if (zodSchemaDef.values.some((literal) => literal === null)) {
+          throw new Error("z.literal() with null is not supported");
+        }
+        if (
+          zodSchemaDef.values.some((literal) => typeof literal === "bigint")
+        ) {
+          throw new Error("z.literal() with bigint is not supported");
+        }
+        return coField.literal(
+          ...(zodSchemaDef.values as Exclude<
+            (typeof zodSchemaDef.values)[number],
+            undefined | null | bigint
+          >[]),
+        );
+      } else if (
+        zodSchemaDef.type === "object" ||
+        zodSchemaDef.type === "array" ||
+        zodSchemaDef.type === "tuple"
+      ) {
+        return coField.json();
+      } else if (zodSchemaDef.type === "union") {
+        if (isUnionOfPrimitivesDeeply(schema)) {
+          return coField.json();
+        } else {
+          throw new Error(
+            "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead.",
+          );
+        }
+      } else {
+        throw new Error(
+          `Unsupported zod type: ${(schema._zod?.def as any)?.type || JSON.stringify(schema)}`,
+        );
+      }
+    } else {
+      throw new Error(`Unsupported zod type: ${schema}`);
+    }
+  }
+}

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

@@ -9,8 +9,13 @@ import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 import { z } from "../zodReExport.js";
-import { Loaded, ResolveQuery } from "../zodSchema.js";
-import { AnyCoMapSchema, CoMapSchema } from "./CoMapSchema.js";
+import { AnyZodOrCoValueSchema, Loaded, ResolveQuery } from "../zodSchema.js";
+import {
+  CoMapSchema,
+  CoMapSchemaDefinition,
+  CoreCoMapSchema,
+  createCoreCoMapSchema,
+} from "./CoMapSchema.js";
 
 export type BaseProfileShape = {
   name: z.core.$ZodString<string>;
@@ -19,8 +24,8 @@ export type BaseProfileShape = {
 };
 
 export type BaseAccountShape = {
-  profile: AnyCoMapSchema<BaseProfileShape>;
-  root: AnyCoMapSchema;
+  profile: CoreCoMapSchema<BaseProfileShape>;
+  root: CoreCoMapSchema;
 };
 
 export type DefaultAccountShape = {
@@ -28,9 +33,18 @@ export type DefaultAccountShape = {
   root: CoMapSchema<{}>;
 };
 
-export type AccountSchema<
+export interface AccountSchema<
   Shape extends BaseAccountShape = DefaultAccountShape,
-> = Omit<CoMapSchema<Shape>, "create" | "load" | "withMigration"> & {
+> extends CoreAccountSchema<Shape>,
+    Omit<
+      CoMapSchema<Shape>,
+      | "builtin"
+      | "getDefinition"
+      | "create"
+      | "load"
+      | "withMigration"
+      | "getCoValueClass"
+    > {
   builtin: "Account";
 
   create: (options: {
@@ -63,10 +77,19 @@ export type AccountSchema<
   ): AccountSchema<Shape>;
 
   getCoValueClass: () => typeof Account;
-};
+}
+
+export function createCoreAccountSchema<Shape extends BaseAccountShape>(
+  shape: Shape,
+): CoreAccountSchema<Shape> {
+  return {
+    ...createCoreCoMapSchema(shape),
+    builtin: "Account" as const,
+  };
+}
 
 export function enrichAccountSchema<Shape extends BaseAccountShape>(
-  schema: AnyAccountSchema<Shape>,
+  schema: CoreAccountSchema<Shape>,
   coValueClass: typeof Account,
 ): AccountSchema<Shape> {
   const enrichedSchema = Object.assign(schema, {
@@ -90,9 +113,6 @@ export function enrichAccountSchema<Shape extends BaseAccountShape>(
       // @ts-expect-error
       return coValueClass.subscribe(...args);
     },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
     fromRaw: (...args: any[]) => {
       // @ts-expect-error
       return coValueClass.fromRaw(...args);
@@ -127,16 +147,15 @@ export type DefaultProfileShape = {
 
 export type CoProfileSchema<
   Shape extends z.core.$ZodLooseShape = DefaultProfileShape,
-  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
-> = CoMapSchema<Shape & DefaultProfileShape, Config, Group>;
+  CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
+> = CoMapSchema<Shape & DefaultProfileShape, CatchAll, Group>;
 
 // less precise version to avoid circularity issues and allow matching against
-export type AnyAccountSchema<
+export interface CoreAccountSchema<
   Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
-> = z.core.$ZodObject<Shape> & {
-  collaborative: true;
+> extends Omit<CoreCoMapSchema<Shape>, "builtin"> {
   builtin: "Account";
-};
+}
 
 export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
   -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;

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

@@ -1,34 +1,61 @@
 import {
   Account,
   AnonymousJazzAgent,
-  AnyCoSchema,
+  InstanceOfSchema,
   InstanceOrPrimitiveOfSchemaCoValuesNullable,
-  RefsToResolve,
-  RefsToResolveStrict,
   Resolved,
   SchemaUnion,
+  SchemaUnionConcreteSubclass,
   SubscribeListenerOptions,
+  coOptionalDefiner,
 } from "../../../internal.js";
 import { z } from "../zodReExport.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-export type AnyDiscriminableCoSchema = AnyCoSchema &
-  z.core.$ZodTypeDiscriminable;
+export interface DiscriminableCoValueSchemaDefinition {
+  discriminatorMap: z.core.$ZodDiscriminatedUnionInternals["propValues"];
+}
+
+export interface DiscriminableCoreCoValueSchema extends CoreCoValueSchema {
+  getDefinition: () => DiscriminableCoValueSchemaDefinition;
+}
+
+export interface CoDiscriminatedUnionSchemaDefinition<
+  Options extends DiscriminableCoValueSchemas,
+> extends DiscriminableCoValueSchemaDefinition {
+  discriminator: string;
+  options: Options;
+}
+
+export type DiscriminableCoValueSchemas = [
+  DiscriminableCoreCoValueSchema,
+  ...DiscriminableCoreCoValueSchema[],
+];
+
+export interface CoreCoDiscriminatedUnionSchema<
+  Options extends DiscriminableCoValueSchemas = DiscriminableCoValueSchemas,
+> extends DiscriminableCoreCoValueSchema {
+  builtin: "CoDiscriminatedUnion";
+  getDefinition: () => CoDiscriminatedUnionSchemaDefinition<Options>;
+}
+export class CoDiscriminatedUnionSchema<
+  Options extends DiscriminableCoValueSchemas,
+> implements CoreCoDiscriminatedUnionSchema<Options>
+{
+  readonly collaborative = true as const;
+  readonly builtin = "CoDiscriminatedUnion" as const;
+  readonly getDefinition: () => CoDiscriminatedUnionSchemaDefinition<Options>;
 
-export type AnyCoDiscriminatedUnionSchema<
-  Types extends readonly [
-    AnyDiscriminableCoSchema,
-    ...AnyDiscriminableCoSchema[],
-  ],
-> = z.ZodDiscriminatedUnion<Types> & {
-  collaborative: true;
-};
+  constructor(
+    coreSchema: CoreCoDiscriminatedUnionSchema<Options>,
+    private coValueClass: SchemaUnionConcreteSubclass<
+      InstanceOfSchema<Options[number]>
+    >,
+  ) {
+    this.getDefinition = coreSchema.getDefinition;
+  }
 
-export type CoDiscriminatedUnionSchema<
-  Types extends readonly [
-    AnyDiscriminableCoSchema,
-    ...AnyDiscriminableCoSchema[],
-  ],
-> = AnyCoDiscriminatedUnionSchema<Types> & {
   load(
     id: string,
     options?: {
@@ -36,55 +63,77 @@ export type CoDiscriminatedUnionSchema<
       skipRetry?: boolean;
     },
   ): Promise<Resolved<
-    CoDiscriminatedUnionInstanceCoValuesNullable<Types> & SchemaUnion,
+    CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
     true
-  > | null>;
+  > | null> {
+    return this.coValueClass.load(id, options) as any;
+  }
 
   subscribe(
     id: string,
     options: SubscribeListenerOptions<
-      CoDiscriminatedUnionInstanceCoValuesNullable<Types> & SchemaUnion,
+      CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
       true
     >,
     listener: (
       value: Resolved<
-        CoDiscriminatedUnionInstanceCoValuesNullable<Types> & SchemaUnion,
+        CoDiscriminatedUnionInstanceCoValuesNullable<Options> & SchemaUnion,
         true
       >,
       unsubscribe: () => void,
     ) => void,
-  ): () => void;
+  ): () => void {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(id, options, listener);
+  }
 
-  getCoValueClass: () => typeof SchemaUnion;
-};
+  getCoValueClass(): SchemaUnionConcreteSubclass<
+    InstanceOfSchema<Options[number]>
+  > {
+    return this.coValueClass;
+  }
+
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
+}
 
-export function enrichCoDiscriminatedUnionSchema<
-  Types extends readonly [
-    AnyDiscriminableCoSchema,
-    ...AnyDiscriminableCoSchema[],
-  ],
+export function createCoreCoDiscriminatedUnionSchema<
+  Options extends DiscriminableCoValueSchemas,
 >(
-  schema: z.ZodDiscriminatedUnion<Types>,
-  coValueClass: typeof SchemaUnion,
-): CoDiscriminatedUnionSchema<Types> {
-  return Object.assign(schema, {
-    load: (...args: [any, ...any]) => {
-      // @ts-expect-error
-      return coValueClass.load(...args);
-    },
-    subscribe: (...args: [any, ...any[]]) => {
-      // @ts-expect-error
-      return coValueClass.subscribe(...args);
-    },
-    getCoValueClass: () => {
-      return coValueClass;
-    },
-  }) as unknown as CoDiscriminatedUnionSchema<Types>;
+  discriminator: string,
+  schemas: Options,
+): CoreCoDiscriminatedUnionSchema<Options> {
+  return {
+    collaborative: true as const,
+    builtin: "CoDiscriminatedUnion" as const,
+    getDefinition: () => ({
+      discriminator,
+      get discriminatorMap() {
+        const propValues: DiscriminableCoValueSchemaDefinition["discriminatorMap"] =
+          {};
+        for (const option of schemas) {
+          const dm = option.getDefinition().discriminatorMap;
+          if (!dm || Object.keys(dm).length === 0)
+            throw new Error(
+              `Invalid discriminated union option at index "${schemas.indexOf(option)}"`,
+            );
+          for (const [k, v] of Object.entries(dm)) {
+            propValues[k] ??= new Set();
+            for (const val of v) {
+              propValues[k].add(val);
+            }
+          }
+        }
+        return propValues;
+      },
+      get options() {
+        return schemas;
+      },
+    }),
+  };
 }
 
 type CoDiscriminatedUnionInstanceCoValuesNullable<
-  Types extends readonly [
-    AnyDiscriminableCoSchema,
-    ...AnyDiscriminableCoSchema[],
-  ],
-> = NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<Types[number]>>;
+  Options extends DiscriminableCoValueSchemas,
+> = NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<Options[number]>>;

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

@@ -1,36 +1,43 @@
 import {
   Account,
+  AnyZodOrCoValueSchema,
   CoFeed,
   Group,
+  NotNull,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
+  Simplify,
   SubscribeListenerOptions,
+  coOptionalDefiner,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { InstanceOfSchema } from "../typeConverters/InstanceOfSchema.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
-import { z } from "../zodReExport.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-type CoFeedInit<T extends z.core.$ZodType> = Array<
-  T extends z.core.$ZodOptional<any>
-    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
-    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>
+type CoFeedInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  Array<NotNull<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>>
 >;
 
-export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
-  CoFeed<InstanceOfSchema<T>>,
-  unknown
-> & {
-  collaborative: true;
-  builtin: "CoFeed";
-  element: T;
+export class CoFeedSchema<T extends AnyZodOrCoValueSchema>
+  implements CoreCoFeedSchema<T>
+{
+  collaborative = true as const;
+  builtin = "CoFeed" as const;
+
+  constructor(
+    public element: T,
+    private coValueClass: typeof CoFeed,
+  ) {}
 
   create(
     init: CoFeedInit<T>,
     options?: { owner: Account | Group } | Account | Group,
-  ): CoFeedInstance<T>;
+  ): CoFeedInstance<T> {
+    return this.coValueClass.create(init, options) as CoFeedInstance<T>;
+  }
 
   load<const R extends RefsToResolve<CoFeedInstanceCoValuesNullable<T>> = true>(
     id: string,
@@ -38,7 +45,10 @@ export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
       resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesNullable<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<Resolved<CoFeedInstanceCoValuesNullable<T>, R> | null>;
+  ): Promise<Resolved<CoFeedInstanceCoValuesNullable<T>, R> | null> {
+    // @ts-expect-error
+    return this.coValueClass.load(id, options);
+  }
 
   subscribe(
     id: string,
@@ -57,47 +67,41 @@ export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
       unsubscribe: () => void,
     ) => void,
   ): () => void;
+  subscribe(...args: [any, ...any[]]) {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(...args);
+  }
 
-  getCoValueClass: () => typeof CoFeed;
-};
+  getCoValueClass(): typeof CoFeed {
+    return this.coValueClass;
+  }
 
-export function enrichCoFeedSchema<T extends z.core.$ZodType>(
-  schema: AnyCoFeedSchema<T>,
-  coValueClass: typeof CoFeed,
-): CoFeedSchema<T> {
-  return Object.assign(schema, {
-    create: (...args: [any, ...any[]]) => {
-      return coValueClass.create(...args);
-    },
-    load: (...args: [any, ...any[]]) => {
-      // @ts-expect-error
-      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 CoFeedSchema<T>;
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
 }
 
-// less precise version to avoid circularity issues and allow matching against
-export type AnyCoFeedSchema<T extends z.core.$ZodType = z.core.$ZodType> =
-  z.core.$ZodCustom<any, unknown> & {
-    collaborative: true;
-    builtin: "CoFeed";
-    element: T;
+export function createCoreCoFeedSchema<T extends AnyZodOrCoValueSchema>(
+  element: T,
+): CoreCoFeedSchema<T> {
+  return {
+    collaborative: true as const,
+    builtin: "CoFeed" as const,
+    element,
   };
+}
+
+// less precise version to avoid circularity issues and allow matching against
+export interface CoreCoFeedSchema<
+  T extends AnyZodOrCoValueSchema = AnyZodOrCoValueSchema,
+> extends CoreCoValueSchema {
+  builtin: "CoFeed";
+  element: T;
+}
 
-export type CoFeedInstance<T extends z.core.$ZodType> = CoFeed<
+export type CoFeedInstance<T extends AnyZodOrCoValueSchema> = CoFeed<
   InstanceOrPrimitiveOfSchema<T>
 >;
 
-export type CoFeedInstanceCoValuesNullable<T extends z.core.$ZodType> = CoFeed<
-  InstanceOrPrimitiveOfSchemaCoValuesNullable<T>
->;
+export type CoFeedInstanceCoValuesNullable<T extends AnyZodOrCoValueSchema> =
+  CoFeed<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>;