jazz-tools 0.15.9 → 0.15.11

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

@@ -19,9 +19,7 @@ type CoListInit<T extends z.core.$ZodType> = Array<
     : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>>
 >;
 
-export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
-  collaborative: true;
-
+export type CoListSchema<T extends z.core.$ZodType> = AnyCoListSchema<T> & {
   create: (
     items: CoListInit<T>,
     options?: { owner: Account | Group } | Account | Group,
@@ -52,10 +50,34 @@ export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
     helpers: (Self: S) => T,
   ): WithHelpers<S, T>;
 
-  getCoSchema: () => typeof CoList;
+  getCoValueClass: () => typeof CoList;
 };
 
-// less precise verion to avoid circularity issues and allow matching against
+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>;
+}
+
+// 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 };
 

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

@@ -8,6 +8,7 @@ import {
   Resolved,
   Simplify,
   SubscribeListenerOptions,
+  zodSchemaToCoSchema,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
@@ -19,10 +20,8 @@ export type CoMapSchema<
   Shape extends z.core.$ZodLooseShape,
   Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
   Owner extends Account | Group = Account | Group,
-> = z.core.$ZodObject<Shape, Config> &
+> = AnyCoMapSchema<Shape, Config> &
   z.$ZodTypeDiscriminable & {
-    collaborative: true;
-
     create: (
       init: Simplify<CoMapInitZod<Shape>>,
       options?:
@@ -145,9 +144,65 @@ export type CoMapSchema<
       ) => undefined,
     ): CoMapSchema<Shape, Config, Owner>;
 
-    getCoSchema: () => typeof CoMap;
+    getCoValueClass: () => typeof CoMap;
   };
 
+export function enrichCoMapSchema<
+  Shape extends z.core.$ZodLooseShape,
+  Config extends z.core.$ZodObjectConfig,
+>(
+  schema: AnyCoMapSchema<Shape, Config>,
+  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;
+  const coValueSchema = 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);
+    },
+    findUnique: (...args: [any, ...any[]]) => {
+      // @ts-expect-error
+      return coValueClass.findUnique(...args);
+    },
+    upsertUnique: (...args: [any, ...any[]]) => {
+      // @ts-expect-error
+      return coValueClass.upsertUnique(...args);
+    },
+    loadUnique: (...args: [any, ...any[]]) => {
+      // @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));
+    },
+    withMigration: (migration: (value: any) => undefined) => {
+      // @ts-expect-error TODO check
+      coValueClass.prototype.migrate = migration;
+
+      return coValueSchema;
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    },
+  }) as unknown as CoMapSchema<Shape, Config>;
+  return coValueSchema;
+}
+
 export type optionalKeys<Shape extends z.core.$ZodLooseShape> = {
   [key in keyof Shape]: Shape[key] extends z.core.$ZodOptional<any>
     ? key
@@ -170,7 +225,7 @@ export type CoMapInitZod<Shape extends z.core.$ZodLooseShape> = {
   >;
 } & { [key in keyof Shape]?: unknown };
 
-// less precise verion to avoid circularity issues and allow matching against
+// less precise version to avoid circularity issues and allow matching against
 export type AnyCoMapSchema<
   Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
   Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,

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

@@ -0,0 +1,33 @@
+import { isAnyCoValueSchema } from "../runtimeConverters/zodSchemaToCoSchema.js";
+import { z } from "../zodReExport.js";
+import { AnyCoSchema, CoValueSchemaFromZodSchema } from "../zodSchema.js";
+
+export type AnyCoOptionalSchema<
+  Shape extends z.core.$ZodType = z.core.$ZodType,
+> = z.ZodOptional<Shape> & {
+  collaborative: true;
+};
+
+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 function isAnyCoOptionalSchema(
+  schema: z.core.$ZodType,
+): schema is CoOptionalSchema<z.core.$ZodType> {
+  return isAnyCoValueSchema(schema) && schema._zod.def.type === "optional";
+}

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

@@ -28,9 +28,7 @@ type CoRecordInit<
 export type CoRecordSchema<
   K extends z.core.$ZodString<string>,
   V extends z.core.$ZodType,
-> = z.core.$ZodRecord<K, V> & {
-  collaborative: true;
-
+> = AnyCoRecordSchema<K, V> & {
   create: (
     init: Simplify<CoRecordInit<K, V>>,
     options?:
@@ -83,10 +81,10 @@ export type CoRecordSchema<
     this: S,
     helpers: (Self: S) => T,
   ): WithHelpers<S, T>;
-  getCoSchema: () => typeof CoMap;
+  getCoValueClass: () => typeof CoMap;
 };
 
-// less precise verion to avoid circularity issues and allow matching against
+// less precise version to avoid circularity issues and allow matching against
 export type AnyCoRecordSchema<
   K extends z.core.$ZodString<string> = z.core.$ZodString<string>,
   V extends z.core.$ZodType = z.core.$ZodType,

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

@@ -6,9 +6,12 @@ import {
 } from "../../../internal.js";
 import { z } from "../zodReExport.js";
 
-export type FileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
+export type AnyFileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
   collaborative: true;
   builtin: "FileStream";
+};
+
+export type FileStreamSchema = AnyFileStreamSchema & {
   create(options?: { owner?: Account | Group } | Account | Group): FileStream;
   createFromBlob(
     blob: Blob | File,
@@ -40,5 +43,32 @@ export type FileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
     id: string,
     listener: (value: FileStream, unsubscribe: () => void) => void,
   ): () => void;
-  getCoSchema: () => typeof FileStream;
+  getCoValueClass: () => typeof FileStream;
 };
+
+export function enrichFileStreamSchema(
+  schema: AnyFileStreamSchema,
+  coValueClass: typeof FileStream,
+): FileStreamSchema {
+  return Object.assign(schema, {
+    create: (...args: any[]) => {
+      return coValueClass.create(...args);
+    },
+    createFromBlob: (...args: [any, ...any[]]) => {
+      return coValueClass.createFromBlob(...args);
+    },
+    load: (...args: [any, ...any[]]) => {
+      return coValueClass.load(...args);
+    },
+    loadAsBlob: (...args: [any, ...any[]]) => {
+      return coValueClass.loadAsBlob(...args);
+    },
+    subscribe: (...args: [any, ...any[]]) => {
+      // @ts-expect-error
+      return coValueClass.subscribe(...args);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    },
+  }) as unknown as FileStreamSchema;
+}

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

@@ -3,9 +3,12 @@ import { Account, CoPlainText, Group } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { z } from "../zodReExport.js";
 
-export type PlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
+export type AnyPlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
   collaborative: true;
   builtin: "CoPlainText";
+};
+
+export type PlainTextSchema = AnyPlainTextSchema & {
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,
@@ -24,5 +27,30 @@ export type PlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
     listener: (value: CoPlainText, unsubscribe: () => void) => void,
   ): () => void;
   fromRaw(raw: RawCoPlainText): CoPlainText;
-  getCoSchema: () => typeof CoPlainText;
+  getCoValueClass: () => typeof CoPlainText;
 };
+
+export function enrichPlainTextSchema(
+  schema: AnyPlainTextSchema,
+  coValueClass: typeof CoPlainText,
+): PlainTextSchema {
+  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);
+    },
+    fromRaw: (...args: [any, ...any[]]) => {
+      // @ts-expect-error
+      return coValueClass.fromRaw(...args);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    },
+  }) as unknown as PlainTextSchema;
+}

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

@@ -2,9 +2,12 @@ import { Account, CoRichText, Group } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { z } from "../zodReExport.js";
 
-export type RichTextSchema = z.core.$ZodCustom<CoRichText, unknown> & {
+export type AnyRichTextSchema = z.core.$ZodCustom<CoRichText, unknown> & {
   collaborative: true;
   builtin: "CoRichText";
+};
+
+export type RichTextSchema = AnyRichTextSchema & {
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,
@@ -22,5 +25,26 @@ export type RichTextSchema = z.core.$ZodCustom<CoRichText, unknown> & {
     id: string,
     listener: (value: CoRichText, unsubscribe: () => void) => void,
   ): () => void;
-  getCoSchema: () => typeof CoRichText;
+  getCoValueClass: () => typeof CoRichText;
 };
+
+export function enrichRichTextSchema(
+  schema: AnyRichTextSchema,
+  coValueClass: typeof CoRichText,
+): RichTextSchema {
+  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);
+    },
+    getCoValueClass: () => {
+      return coValueClass;
+    },
+  }) as unknown as RichTextSchema;
+}

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchema.ts

@@ -1,5 +1,7 @@
 import {
   Account,
+  AnyAccountSchema,
+  AnyCoRecordSchema,
   CoFeed,
   CoList,
   CoMap,
@@ -11,24 +13,19 @@ import {
 import { AnyCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
 import { AnyCoListSchema } from "../schemaTypes/CoListSchema.js";
 import { AnyCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { FileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { AnyFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
+import { AnyPlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
+import { AnyRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
 import { InstanceOrPrimitiveOfSchema } from "./InstanceOrPrimitiveOfSchema.js";
 
 export type InstanceOfSchema<S extends CoValueClass | z.core.$ZodType> =
   S extends z.core.$ZodType
-    ? S extends z.core.$ZodObject<infer Shape> & {
-        collaborative: true;
-        builtin: "Account";
-      }
+    ? S extends AnyAccountSchema<infer Shape>
       ? {
           [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
         } & Account
-      : S extends z.core.$ZodRecord<infer K, infer V> & {
-            collaborative: true;
-          }
+      : S extends AnyCoRecordSchema<infer K, infer V>
         ? {
             [key in z.output<K> & string]: InstanceOrPrimitiveOfSchema<V>;
           } & CoMap
@@ -45,11 +42,11 @@ export type InstanceOfSchema<S extends CoValueClass | z.core.$ZodType> =
             ? CoList<InstanceOrPrimitiveOfSchema<T>>
             : S extends AnyCoFeedSchema<infer T>
               ? CoFeed<InstanceOrPrimitiveOfSchema<T>>
-              : S extends PlainTextSchema
+              : S extends AnyPlainTextSchema
                 ? CoPlainText
-                : S extends RichTextSchema
+                : S extends AnyRichTextSchema
                   ? CoRichText
-                  : S extends FileStreamSchema
+                  : S extends AnyFileStreamSchema
                     ? FileStream
                     : S extends z.core.$ZodOptional<infer Inner>
                       ? InstanceOrPrimitiveOfSchema<Inner>

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

@@ -1,5 +1,12 @@
 import { RawAccount, RawCoList, RawCoMap } from "cojson";
-import { zodSchemaToCoSchema } from "./runtimeConverters/zodSchemaToCoSchema.js";
+import { CoValueClass, CoValueFromRaw } from "../../internal.js";
+import {
+  isAnyCoValueSchema,
+  zodSchemaToCoSchema,
+} from "./runtimeConverters/zodSchemaToCoSchema.js";
+import { AccountSchema } from "./schemaTypes/AccountSchema.js";
+import { CoListSchema } from "./schemaTypes/CoListSchema.js";
+import { CoMapSchema } from "./schemaTypes/CoMapSchema.js";
 import { z } from "./zodReExport.js";
 
 export function schemaUnionDiscriminatorFor(
@@ -8,7 +15,7 @@ export function schemaUnionDiscriminatorFor(
   if (isUnionOfCoMapsDeeply(schema)) {
     if (!schema._zod.disc || schema._zod.disc.size == 0) {
       throw new Error(
-        "z.union() of collaborative types is not supported, use z.discriminatedUnion() instead",
+        "z.union() of collaborative types is not supported, use co.discriminatedUnion() instead",
       );
     }
 
@@ -17,14 +24,14 @@ export function schemaUnionDiscriminatorFor(
 
     if (!field) {
       throw new Error(
-        "z.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported",
+        "co.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported",
       );
     }
 
     for (const value of field.values) {
       if (typeof value !== "string" && typeof value !== "number") {
         throw new Error(
-          "z.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported",
+          "co.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported",
         );
       }
     }
@@ -42,7 +49,7 @@ export function schemaUnionDiscriminatorFor(
         }
       } else {
         throw new Error(
-          "Unsupported zod type in z.discriminatedUnion() of collaborative types",
+          "Unsupported zod type in co.discriminatedUnion() of collaborative types",
         );
       }
     }
@@ -50,7 +57,7 @@ export function schemaUnionDiscriminatorFor(
     const determineSchema = (_raw: RawCoMap | RawAccount | RawCoList) => {
       if (_raw instanceof RawCoList) {
         throw new Error(
-          "z.discriminatedUnion() of collaborative types is not supported for CoLists",
+          "co.discriminatedUnion() of collaborative types is not supported for CoLists",
         );
       }
 
@@ -90,12 +97,17 @@ export function schemaUnionDiscriminatorFor(
         }
 
         if (match) {
-          return zodSchemaToCoSchema(option);
+          const coValueSchema = zodSchemaToCoSchema(option) as
+            | CoMapSchema<any>
+            | AccountSchema
+            | CoListSchema<any>;
+          return coValueSchema.getCoValueClass() as CoValueClass<any> &
+            CoValueFromRaw<any>;
         }
       }
 
       throw new Error(
-        "z.discriminatedUnion() of collaborative types with no matching discriminator value found",
+        "co.discriminatedUnion() of collaborative types with no matching discriminator value found",
       );
     };
 
@@ -120,11 +132,7 @@ export function isUnionOfCoMapsDeeply(
 function isCoMapOrUnionOfCoMapsDeeply(
   schema: z.core.$ZodType,
 ): schema is z.core.$ZodDiscriminatedUnion {
-  if (
-    schema instanceof z.core.$ZodObject &&
-    "collaborative" in schema &&
-    schema.collaborative
-  ) {
+  if (schema instanceof z.core.$ZodObject && isAnyCoValueSchema(schema)) {
     return true;
   } else if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
@@ -137,6 +145,6 @@ export function isUnionOfPrimitivesDeeply(schema: z.core.$ZodType) {
   if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
   } else {
-    return !("collaborative" in schema);
+    return !isAnyCoValueSchema(schema);
   }
 }