jazz-tools 0.15.16 → 0.16.0

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

@@ -2,8 +2,10 @@ import { CoValueUniqueness } from "cojson";
 import {
   Account,
   type CoMap,
+  CoMapSchemaDefinition,
   Group,
   ID,
+  NotNull,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
@@ -14,21 +16,21 @@ 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 CoRecordInit<
   K extends z.core.$ZodString<string>,
-  V extends z.core.$ZodType,
+  V extends AnyZodOrCoValueSchema,
 > = {
-  [key in z.output<K>]: V extends z.core.$ZodOptional<any>
-    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<V>
-    : NonNullable<InstanceOrPrimitiveOfSchemaCoValuesNullable<V>>;
+  [key in z.output<K>]: NotNull<InstanceOrPrimitiveOfSchemaCoValuesNullable<V>>;
 };
 
-export type CoRecordSchema<
+export interface CoRecordSchema<
   K extends z.core.$ZodString<string>,
-  V extends z.core.$ZodType,
-> = AnyCoRecordSchema<K, V> & {
+  V extends AnyZodOrCoValueSchema,
+> extends CoreCoRecordSchema<K, V> {
   create: (
     init: Simplify<CoRecordInit<K, V>>,
     options?:
@@ -76,30 +78,38 @@ export type CoRecordSchema<
     as?: Account | Group | AnonymousJazzAgent,
   ): ID<CoRecordInstanceCoValuesNullable<K, V>>;
 
-  /** @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 CoMap;
+
+  optional(): CoOptionalSchema<this>;
+}
+
+type CoRecordSchemaDefinition<
+  K extends z.core.$ZodString<string>,
+  V extends AnyZodOrCoValueSchema,
+> = CoMapSchemaDefinition & {
+  keyType: K;
+  valueType: V;
 };
 
 // less precise version to avoid circularity issues and allow matching against
-export type AnyCoRecordSchema<
+export interface CoreCoRecordSchema<
   K extends z.core.$ZodString<string> = z.core.$ZodString<string>,
-  V extends z.core.$ZodType = z.core.$ZodType,
-> = z.core.$ZodRecord<K, V> & { collaborative: true };
+  V extends AnyZodOrCoValueSchema = AnyZodOrCoValueSchema,
+> extends CoreCoValueSchema {
+  builtin: "CoMap";
+  getDefinition: () => CoRecordSchemaDefinition<K, V>;
+}
 
 export type CoRecordInstance<
   K extends z.core.$ZodString<string>,
-  V extends z.core.$ZodType,
+  V extends AnyZodOrCoValueSchema,
 > = {
   [key in z.output<K>]: InstanceOrPrimitiveOfSchema<V>;
 } & CoMap;
 
 export type CoRecordInstanceCoValuesNullable<
   K extends z.core.$ZodString<string>,
-  V extends z.core.$ZodType,
+  V extends AnyZodOrCoValueSchema,
 > = {
   [key in z.output<K>]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
 } & CoMap;

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

@@ -0,0 +1,18 @@
+/**
+ * "Core" CoValue schemas contain all data necessary to represent a CoValue schema.
+ * Behavior is provided by CoValue schemas that extend "core" CoValue schema data structures.
+ *
+ * "Core" CoValue schemas are necessary to avoid circularity issues when defining schemas.
+ * This is similar to how Zod's "core" schemas are used.
+ *
+ * They are not meant to be used directly outside of the `jazz-tools` package,
+ * use concrete CoValue schemas instead.
+ */
+export interface CoreCoValueSchema {
+  collaborative: true;
+
+  /**
+   * Used for discriminating between different CoValue schemas.
+   */
+  builtin: string;
+}

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

@@ -3,16 +3,32 @@ import {
   AnonymousJazzAgent,
   FileStream,
   Group,
+  coOptionalDefiner,
 } from "../../../internal.js";
-import { z } from "../zodReExport.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-export type AnyFileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
-  collaborative: true;
+export interface CoreFileStreamSchema extends CoreCoValueSchema {
   builtin: "FileStream";
-};
+}
+
+export function createCoreFileStreamSchema(): CoreFileStreamSchema {
+  return {
+    collaborative: true as const,
+    builtin: "FileStream" as const,
+  };
+}
+
+export class FileStreamSchema implements CoreFileStreamSchema {
+  readonly collaborative = true as const;
+  readonly builtin = "FileStream" as const;
+
+  constructor(private coValueClass: typeof FileStream) {}
+
+  create(options?: { owner?: Account | Group } | Account | Group): FileStream {
+    return this.coValueClass.create(options);
+  }
 
-export type FileStreamSchema = AnyFileStreamSchema & {
-  create(options?: { owner?: Account | Group } | Account | Group): FileStream;
   createFromBlob(
     blob: Blob | File,
     options?:
@@ -22,18 +38,27 @@ export type FileStreamSchema = AnyFileStreamSchema & {
         }
       | Account
       | Group,
-  ): Promise<FileStream>;
+  ): Promise<FileStream> {
+    return this.coValueClass.createFromBlob(blob, options);
+  }
+
   loadAsBlob(
     id: string,
     options?: {
       allowUnfinished?: boolean;
       loadAs?: Account | AnonymousJazzAgent;
     },
-  ): Promise<Blob | undefined>;
+  ): Promise<Blob | undefined> {
+    return this.coValueClass.loadAsBlob(id, options);
+  }
+
   load(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
-  ): Promise<FileStream>;
+  ): Promise<FileStream | null> {
+    return this.coValueClass.load(id, options);
+  }
+
   subscribe(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
@@ -43,32 +68,16 @@ export type FileStreamSchema = AnyFileStreamSchema & {
     id: string,
     listener: (value: FileStream, unsubscribe: () => void) => void,
   ): () => void;
-  getCoValueClass: () => typeof FileStream;
-};
+  subscribe(...args: [any, ...any[]]) {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(...args);
+  }
 
-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;
+  getCoValueClass(): typeof FileStream {
+    return this.coValueClass;
+  }
+
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
 }

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

@@ -1,22 +1,45 @@
 import { RawCoPlainText } from "cojson";
-import { Account, CoPlainText, Group } from "../../../internal.js";
+import {
+  Account,
+  CoPlainText,
+  Group,
+  coOptionalDefiner,
+} from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { z } from "../zodReExport.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-export type AnyPlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
-  collaborative: true;
+export interface CorePlainTextSchema extends CoreCoValueSchema {
   builtin: "CoPlainText";
-};
+}
+
+export function createCoreCoPlainTextSchema(): CorePlainTextSchema {
+  return {
+    collaborative: true as const,
+    builtin: "CoPlainText" as const,
+  };
+}
+
+export class PlainTextSchema implements CorePlainTextSchema {
+  readonly collaborative = true as const;
+  readonly builtin = "CoPlainText" as const;
+
+  constructor(private coValueClass: typeof CoPlainText) {}
 
-export type PlainTextSchema = AnyPlainTextSchema & {
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,
-  ): CoPlainText;
+  ): CoPlainText {
+    return this.coValueClass.create(text, options);
+  }
+
   load(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
-  ): Promise<CoPlainText>;
+  ): Promise<CoPlainText | null> {
+    return this.coValueClass.load(id, options);
+  }
+
   subscribe(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
@@ -26,31 +49,20 @@ export type PlainTextSchema = AnyPlainTextSchema & {
     id: string,
     listener: (value: CoPlainText, unsubscribe: () => void) => void,
   ): () => void;
-  fromRaw(raw: RawCoPlainText): 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;
+  subscribe(...args: [any, ...any[]]) {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(...args);
+  }
+
+  fromRaw(raw: RawCoPlainText): CoPlainText {
+    return this.coValueClass.fromRaw(raw);
+  }
+
+  getCoValueClass(): typeof CoPlainText {
+    return this.coValueClass;
+  }
+
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
 }

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

@@ -1,21 +1,44 @@
-import { Account, CoRichText, Group } from "../../../internal.js";
+import {
+  Account,
+  CoRichText,
+  Group,
+  coOptionalDefiner,
+} from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
-import { z } from "../zodReExport.js";
+import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import { CoreCoValueSchema } from "./CoValueSchema.js";
 
-export type AnyRichTextSchema = z.core.$ZodCustom<CoRichText, unknown> & {
-  collaborative: true;
+export interface CoreRichTextSchema extends CoreCoValueSchema {
   builtin: "CoRichText";
-};
+}
+
+export function createCoreCoRichTextSchema(): CoreRichTextSchema {
+  return {
+    collaborative: true as const,
+    builtin: "CoRichText" as const,
+  };
+}
+
+export class RichTextSchema implements CoreRichTextSchema {
+  readonly collaborative = true as const;
+  readonly builtin = "CoRichText" as const;
+
+  constructor(private coValueClass: typeof CoRichText) {}
 
-export type RichTextSchema = AnyRichTextSchema & {
   create(
     text: string,
     options?: { owner: Account | Group } | Account | Group,
-  ): CoRichText;
+  ): CoRichText {
+    return this.coValueClass.create(text, options);
+  }
+
   load(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
-  ): Promise<CoRichText>;
+  ): Promise<CoRichText | null> {
+    return this.coValueClass.load(id, options);
+  }
+
   subscribe(
     id: string,
     options: { loadAs: Account | AnonymousJazzAgent },
@@ -25,26 +48,16 @@ export type RichTextSchema = AnyRichTextSchema & {
     id: string,
     listener: (value: CoRichText, unsubscribe: () => void) => void,
   ): () => void;
-  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;
+  subscribe(...args: [any, ...any[]]) {
+    // @ts-expect-error
+    return this.coValueClass.subscribe(...args);
+  }
+
+  getCoValueClass(): typeof CoRichText {
+    return this.coValueClass;
+  }
+
+  optional(): CoOptionalSchema<this> {
+    return coOptionalDefiner(this);
+  }
 }

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

@@ -1,56 +1,61 @@
 import {
   Account,
-  AnyAccountSchema,
-  AnyCoRecordSchema,
+  AnyZodOrCoValueSchema,
+  CoDiscriminatedUnionSchema,
   CoFeed,
   CoList,
   CoMap,
   CoPlainText,
   CoRichText,
   CoValueClass,
+  CoreAccountSchema,
+  CoreCoRecordSchema,
   FileStream,
 } from "../../../internal.js";
-import { AnyCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
-import { AnyCoListSchema } from "../schemaTypes/CoListSchema.js";
-import { AnyCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { AnyFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { AnyPlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { AnyRichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { CoreCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
+import { CoreCoListSchema } from "../schemaTypes/CoListSchema.js";
+import { CoreCoMapSchema } from "../schemaTypes/CoMapSchema.js";
+import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
+import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
+import { CoreRichTextSchema } 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 AnyAccountSchema<infer Shape>
+export type InstanceOfSchema<S extends CoValueClass | AnyZodOrCoValueSchema> =
+  S extends CoreCoValueSchema
+    ? S extends CoreAccountSchema<infer Shape>
       ? {
           [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
         } & Account
-      : S extends AnyCoRecordSchema<infer K, infer V>
+      : S extends CoreCoRecordSchema<infer K, infer V>
         ? {
             [key in z.output<K> & string]: InstanceOrPrimitiveOfSchema<V>;
           } & CoMap
-        : S extends AnyCoMapSchema<infer Shape, infer Config>
+        : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
           ? {
               [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
-            } & (unknown extends Config["out"][string]
+            } & (unknown extends CatchAll
               ? {}
               : {
-                  [key: string]: Config["out"][string];
+                  // @ts-expect-error
+                  [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
                 }) &
               CoMap
-          : S extends AnyCoListSchema<infer T>
+          : S extends CoreCoListSchema<infer T>
             ? CoList<InstanceOrPrimitiveOfSchema<T>>
-            : S extends AnyCoFeedSchema<infer T>
+            : S extends CoreCoFeedSchema<infer T>
               ? CoFeed<InstanceOrPrimitiveOfSchema<T>>
-              : S extends AnyPlainTextSchema
+              : S extends CorePlainTextSchema
                 ? CoPlainText
-                : S extends AnyRichTextSchema
+                : S extends CoreRichTextSchema
                   ? CoRichText
-                  : S extends AnyFileStreamSchema
+                  : S extends CoreFileStreamSchema
                     ? FileStream
-                    : S extends z.core.$ZodOptional<infer Inner>
-                      ? InstanceOrPrimitiveOfSchema<Inner>
-                      : S extends z.core.$ZodUnion<infer Members>
+                    : S extends CoreCoOptionalSchema<infer T>
+                      ? InstanceOrPrimitiveOfSchema<T>
+                      : S extends CoDiscriminatedUnionSchema<infer Members>
                         ? InstanceOrPrimitiveOfSchema<Members[number]>
                         : never
     : S extends CoValueClass

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

@@ -1,29 +1,32 @@
 import {
   Account,
-  AnyCoFeedSchema,
-  AnyCoListSchema,
-  AnyCoMapSchema,
+  AnyZodOrCoValueSchema,
   CoFeed,
   CoList,
   CoMap,
   CoPlainText,
   CoRichText,
   CoValueClass,
+  CoreAccountSchema,
+  CoreCoDiscriminatedUnionSchema,
+  CoreCoFeedSchema,
+  CoreCoListSchema,
+  CoreCoMapSchema,
+  CoreCoRecordSchema,
   FileStream,
 } from "../../../internal.js";
-import { FileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
+import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
+import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
 import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "./InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 
 export type InstanceOfSchemaCoValuesNullable<
-  S extends CoValueClass | z.core.$ZodType,
-> = S extends z.core.$ZodType
-  ? S extends z.core.$ZodObject<infer Shape> & {
-      collaborative: true;
-      builtin: "Account";
-    }
+  S extends CoValueClass | AnyZodOrCoValueSchema,
+> = S extends CoreCoValueSchema
+  ? S extends CoreAccountSchema<infer Shape>
     ?
         | ({
             [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
@@ -31,43 +34,43 @@ export type InstanceOfSchemaCoValuesNullable<
             >;
           } & Account)
         | null
-    : S extends z.core.$ZodRecord<infer K, infer V> & {
-          collaborative: true;
-        }
+    : S extends CoreCoRecordSchema<infer K, infer V>
       ?
           | ({
               [key in z.output<K> &
                 string]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
             } & CoMap)
           | null
-      : S extends AnyCoMapSchema<infer Shape, infer Config>
+      : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
         ?
             | ({
                 [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
                   Shape[key]
                 >;
-              } & (unknown extends Config["out"][string]
+              } & (unknown extends CatchAll
                 ? {}
                 : {
-                    [key: string]: Config["out"][string];
+                    [
+                      key: string // @ts-expect-error
+                    ]: InstanceOrPrimitiveOfSchemaCoValuesNullable<CatchAll>;
                   }) &
                 CoMap)
             | null
-        : S extends AnyCoListSchema<infer T>
+        : S extends CoreCoListSchema<infer T>
           ? CoList<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-          : S extends AnyCoFeedSchema<infer T>
+          : S extends CoreCoFeedSchema<infer T>
             ? CoFeed<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-            : S extends PlainTextSchema
+            : S extends CorePlainTextSchema
               ? CoPlainText | null
-              : S extends RichTextSchema
+              : S extends CoreRichTextSchema
                 ? CoRichText | null
-                : S extends FileStreamSchema
+                : S extends CoreFileStreamSchema
                   ? FileStream | null
-                  : S extends z.core.$ZodOptional<infer Inner>
+                  : S extends CoreCoOptionalSchema<infer Inner>
                     ?
                         | InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner>
                         | undefined
-                    : S extends z.core.$ZodUnion<infer Members>
+                    : S extends CoreCoDiscriminatedUnionSchema<infer Members>
                       ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
                           Members[number]
                         >