jazz-tools 0.15.9 → 0.15.11

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

@@ -1,8 +1,11 @@
 import {
-  type Account,
-  type AccountCreationProps,
   type AccountSchema,
-  type AnyCoMapSchema,
+  AnyAccountSchema,
+  AnyCoFeedSchema,
+  AnyCoListSchema,
+  AnyCoSchema,
+  AnyFileStreamSchema,
+  AnyPlainTextSchema,
   BaseAccountShape,
   CoFeed,
   type CoFeedSchema,
@@ -20,121 +23,31 @@ import {
   type Simplify,
   zodSchemaToCoSchema,
 } from "../../internal.js";
-import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
+import {
+  AnyDiscriminableCoSchema,
+  CoDiscriminatedUnionSchema,
+} from "./schemaTypes/CoDiscriminatedUnionSchema.js";
+import {
+  CoOptionalSchema,
+  createCoOptionalSchema,
+} from "./schemaTypes/CoOptionalSchema.js";
+import {
+  AnyRichTextSchema,
+  RichTextSchema,
+} from "./schemaTypes/RichTextSchema.js";
 import { z } from "./zodReExport.js";
 
-function enrichCoMapSchema<Shape extends z.core.$ZodLooseShape>(
-  schema: z.ZodObject<
-    { -readonly [P in keyof Shape]: Shape[P] },
-    z.core.$strip
-  >,
-) {
-  const baseCatchall = schema.catchall;
-
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    findUnique: (...args: any[]) => {
-      return coSchema.findUnique(...args);
-    },
-    upsertUnique: (...args: any[]) => {
-      return coSchema.upsertUnique(...args);
-    },
-    loadUnique: (...args: any[]) => {
-      return coSchema.loadUnique(...args);
-    },
-    catchall: (index: z.core.$ZodType) => {
-      return enrichCoMapSchema(baseCatchall(index));
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    withMigration: (migration: (value: any) => undefined) => {
-      coSchema.prototype.migrate = migration;
-
-      return enrichedSchema;
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as CoMapSchema<Shape>;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
 export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
   shape: Shape,
 ): CoMapSchema<Shape> => {
   const objectSchema = z.object(shape).meta({
     collaborative: true,
   });
-
-  return enrichCoMapSchema(objectSchema);
-};
-
-function enrichAccountSchema<Shape extends BaseAccountShape>(
-  schema: z.ZodObject<Shape, z.core.$strip>,
-) {
-  const enrichedSchema = Object.assign(schema, {
+  const enrichedSchema = Object.assign(objectSchema, {
     collaborative: true,
-    builtin: "Account",
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    createAs: (...args: any[]) => {
-      return coSchema.createAs(...args);
-    },
-    getMe: (...args: any[]) => {
-      return coSchema.getMe(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    fromRaw: (...args: any[]) => {
-      return coSchema.fromRaw(...args);
-    },
-    withMigration: (
-      migration: (
-        value: any,
-        creationProps?: AccountCreationProps,
-      ) => void | Promise<void>,
-    ) => {
-      (coSchema.prototype as Account).migrate = async function (
-        this,
-        creationProps,
-      ) {
-        await migration(this, creationProps);
-      };
-
-      return enrichedSchema;
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as AccountSchema<Shape>;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
+  });
+  return zodSchemaToCoSchema(enrichedSchema);
+};
 
 /**
  * Defines a collaborative account schema for Jazz applications.
@@ -183,11 +96,14 @@ export const coAccountDefiner = <Shape extends BaseAccountShape>(
     root: coMapDefiner({}),
   } as unknown as Shape,
 ): AccountSchema<Shape> => {
-  const objectSchema = z.object(shape).meta({
+  const schema = z.object(shape).meta({
     collaborative: true,
   });
-
-  return enrichAccountSchema(objectSchema) as unknown as AccountSchema<Shape>;
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "Account",
+  }) as AnyAccountSchema<Shape>;
+  return zodSchemaToCoSchema(enrichedSchema);
 };
 
 export const coRecordDefiner = <
@@ -203,190 +119,86 @@ export const coRecordDefiner = <
   >;
 };
 
-function enrichCoListSchema<T extends z.core.$ZodType>(schema: z.ZodArray<T>) {
-  const enrichedSchema = Object.assign(schema, {
-    collaborative: true,
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as CoListSchema<T>;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
 export const coListDefiner = <T extends z.core.$ZodType>(
   element: T,
 ): CoListSchema<T> => {
-  const arraySchema = z.array(element).meta({
+  const schema = z.array(element).meta({
     collaborative: true,
   });
-
-  return enrichCoListSchema(arraySchema);
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+  }) as AnyCoListSchema<T>;
+  return zodSchemaToCoSchema(enrichedSchema) as unknown as CoListSchema<T>;
 };
 
 export const coProfileDefiner = <
   Shape extends z.core.$ZodLooseShape = Simplify<DefaultProfileShape>,
 >(
-  shape: Shape & {
-    name?: z.core.$ZodString<string>;
-    inbox?: z.core.$ZodOptional<z.core.$ZodString>;
-    inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
-  } = {} as any,
+  shape: Shape & Partial<DefaultProfileShape> = {} as any,
 ): CoProfileSchema<Shape> => {
-  const ehnancedShape = Object.assign(shape ?? {}, {
+  const ehnancedShape = Object.assign(shape, {
     name: z.string(),
     inbox: z.optional(z.string()),
     inboxInvite: z.optional(z.string()),
   });
-
   return coMapDefiner(ehnancedShape) as CoProfileSchema<Shape>;
 };
 
-function enrichCoFeedSchema<T extends z.core.$ZodType>(
-  schema: z.ZodCustom<CoFeed<unknown>, unknown>,
+export const coFeedDefiner = <T extends z.core.$ZodType>(
   element: T,
-) {
+): CoFeedSchema<T> => {
+  const schema = z.instanceof(CoFeed);
   const enrichedSchema = Object.assign(schema, {
     collaborative: true,
     builtin: "CoFeed",
     element,
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
-      return Object.assign(schema, helpers(schema));
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as CoFeedSchema<T>;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
-export const coFeedDefiner = <T extends z.core.$ZodType>(
-  element: T,
-): CoFeedSchema<T> => {
-  return enrichCoFeedSchema(z.instanceof(CoFeed), element);
+  }) as AnyCoFeedSchema<T>;
+  return zodSchemaToCoSchema(enrichedSchema);
 };
 
-function enrichFileStreamSchema(schema: z.ZodCustom<FileStream, unknown>) {
+export const coFileStreamDefiner = (): FileStreamSchema => {
+  const schema = z.instanceof(FileStream);
   const enrichedSchema = Object.assign(schema, {
     collaborative: true,
     builtin: "FileStream",
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    createFromBlob: (...args: any[]) => {
-      return coSchema.createFromBlob(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    loadAsBlob: (...args: any[]) => {
-      return coSchema.loadAsBlob(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as FileStreamSchema;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
-export const coFileStreamDefiner = (): FileStreamSchema => {
-  return enrichFileStreamSchema(z.instanceof(FileStream));
+  }) as AnyFileStreamSchema;
+  return zodSchemaToCoSchema(enrichedSchema);
 };
 
-function enrichPlainTextSchema(schema: z.ZodCustom<CoPlainText, unknown>) {
+export const coPlainTextDefiner = (): PlainTextSchema => {
+  const schema = z.instanceof(CoPlainText);
   const enrichedSchema = Object.assign(schema, {
     collaborative: true,
     builtin: "CoPlainText",
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    fromRaw: (...args: any[]) => {
-      return coSchema.fromRaw(...args);
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as PlainTextSchema;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
-export const coPlainTextDefiner = (): PlainTextSchema => {
-  return enrichPlainTextSchema(z.instanceof(CoPlainText));
+  }) as AnyPlainTextSchema;
+  return zodSchemaToCoSchema(enrichedSchema);
 };
 
-function enrichRichTextSchema(schema: z.ZodCustom<CoRichText, unknown>) {
+export const coRichTextDefiner = (): RichTextSchema => {
+  const schema = z.instanceof(CoRichText);
   const enrichedSchema = Object.assign(schema, {
     collaborative: true,
     builtin: "CoRichText",
-    create: (...args: any[]) => {
-      return coSchema.create(...args);
-    },
-    load: (...args: any[]) => {
-      return coSchema.load(...args);
-    },
-    subscribe: (...args: any[]) => {
-      return coSchema.subscribe(...args);
-    },
-    getCoSchema: () => {
-      return coSchema;
-    },
-  }) as unknown as RichTextSchema;
-
-  // Needs to be derived from the enriched schema
-  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
-
-  return enrichedSchema;
-}
-
-export const coRichTextDefiner = (): RichTextSchema => {
-  return enrichRichTextSchema(z.instanceof(CoRichText));
+  }) as AnyRichTextSchema;
+  return zodSchemaToCoSchema(enrichedSchema);
 };
 
 export const coImageDefiner = (): typeof ImageDefinition => {
   return ImageDefinition;
 };
+
+export const coOptionalDefiner = <T extends AnyCoSchema>(
+  schema: T,
+): CoOptionalSchema<T> => {
+  return createCoOptionalSchema(schema);
+};
+
+export const coDiscriminatedUnionDefiner = <
+  T extends readonly [AnyDiscriminableCoSchema, ...AnyDiscriminableCoSchema[]],
+>(
+  discriminator: string,
+  schemas: T,
+): CoDiscriminatedUnionSchema<T> => {
+  const schema = z.discriminatedUnion(discriminator, schemas as any);
+  return zodSchemaToCoSchema(schema);
+};

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

@@ -1,13 +1,19 @@
+import {
+  ZodArray,
+  ZodTuple,
+  ZodUnion,
+  core,
+  array as zodArray,
+  tuple as zodTuple,
+  union as zodUnion,
+} from "zod/v4";
 export {
   string,
   number,
   boolean,
-  union,
   object,
-  array,
   templateLiteral,
   json,
-  tuple,
   date,
   emoji,
   base64,
@@ -29,8 +35,8 @@ export {
   int32,
   strictObject,
   discriminatedUnion,
-  //   intersection,
-  //   record,
+  // record,
+  // intersection,
   int,
   optional,
   type ZodOptional,
@@ -39,5 +45,29 @@ export {
   type ZodDefault,
   type ZodCatch,
   type output as infer,
+  type ZodDiscriminatedUnion,
   z,
 } from "zod/v4";
+
+type NonCoZodType = core.$ZodType & { collaborative?: false };
+
+export function union<const T extends readonly NonCoZodType[]>(
+  options: T,
+  params?: string | core.$ZodUnionParams,
+): ZodUnion<T> {
+  return zodUnion(options, params);
+}
+
+export function array<T extends NonCoZodType>(
+  element: T,
+  params?: string | core.$ZodArrayParams,
+): ZodArray<T> {
+  return zodArray(element, params);
+}
+
+export function tuple<T extends readonly [NonCoZodType, ...NonCoZodType[]]>(
+  options: T,
+  params?: string | core.$ZodTupleParams,
+): ZodTuple<T> {
+  return zodTuple(options, params);
+}

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

@@ -2,23 +2,47 @@ import { LocalNode, RawAccount } from "cojson";
 import {
   Account,
   AccountClass,
-  CoValue,
   CoValueClass,
   CoValueFromRaw,
+  InstanceOfSchema,
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
   Simplify,
 } from "../../internal.js";
-import { AnyAccountSchema } from "./schemaTypes/AccountSchema.js";
-import { AnyCoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
-import { AnyCoListSchema } from "./schemaTypes/CoListSchema.js";
-import { AnyCoMapSchema, CoMapInitZod } from "./schemaTypes/CoMapSchema.js";
-import { AnyCoRecordSchema } from "./schemaTypes/CoRecordSchema.js";
-import { FileStreamSchema } from "./schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "./schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
-import { InstanceOfSchema } from "./typeConverters/InstanceOfSchema.js";
+import {
+  AccountSchema,
+  AnyAccountSchema,
+  BaseAccountShape,
+} from "./schemaTypes/AccountSchema.js";
+import {
+  AnyDiscriminableCoSchema,
+  CoDiscriminatedUnionSchema,
+} from "./schemaTypes/CoDiscriminatedUnionSchema.js";
+import { AnyCoFeedSchema, CoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
+import { AnyCoListSchema, CoListSchema } from "./schemaTypes/CoListSchema.js";
+import {
+  AnyCoMapSchema,
+  CoMapInitZod,
+  CoMapSchema,
+} from "./schemaTypes/CoMapSchema.js";
+import { AnyCoOptionalSchema } from "./schemaTypes/CoOptionalSchema.js";
+import {
+  AnyCoRecordSchema,
+  CoRecordSchema,
+} from "./schemaTypes/CoRecordSchema.js";
+import {
+  AnyFileStreamSchema,
+  FileStreamSchema,
+} from "./schemaTypes/FileStreamSchema.js";
+import {
+  AnyPlainTextSchema,
+  PlainTextSchema,
+} from "./schemaTypes/PlainTextSchema.js";
+import {
+  AnyRichTextSchema,
+  RichTextSchema,
+} from "./schemaTypes/RichTextSchema.js";
 import { InstanceOfSchemaCoValuesNullable } from "./typeConverters/InstanceOfSchemaCoValuesNullable.js";
 import { z } from "./zodReExport.js";
 
@@ -47,7 +71,7 @@ export type AnyCoUnionSchema = z.core.$ZodDiscriminatedUnion<
 // this is a series of hacks to work around z4 removing _zod at runtime from z.core.$ZodType
 export function isZodObject(
   schema: z.core.$ZodType,
-): schema is z.core.$ZodObject<any, any> {
+): schema is z.ZodObject<any, any> {
   return (schema as any).def?.type === "object";
 }
 
@@ -67,19 +91,53 @@ export function getDef<S extends z.core.$ZodType>(schema: S): S["_zod"]["def"] {
   return (schema as any).def;
 }
 
+// TODO rename. This represents a CoValue class or a CoValue schema
 export type CoValueOrZodSchema = CoValueClass | AnyCoSchema;
 
-export type CoValueClassFromZodSchema<S extends z.core.$ZodType> = CoValueClass<
-  InstanceOfSchema<S>
-> &
-  CoValueFromRaw<InstanceOfSchema<S>> &
-  (S extends AnyAccountSchema ? AccountClassEssentials : {});
+// TODO rename to CoValueSchemaFromCoProtoSchema
+export type CoValueSchemaFromZodSchema<S extends z.core.$ZodType> =
+  S extends z.core.$ZodType
+    ? S extends AnyAccountSchema<infer Shape extends BaseAccountShape>
+      ? AccountSchema<Shape>
+      : S extends AnyCoRecordSchema<infer K, infer V>
+        ? CoRecordSchema<K, V>
+        : S extends AnyCoMapSchema<infer Shape, infer Config>
+          ? CoMapSchema<Shape, Config>
+          : S extends AnyCoListSchema<infer T>
+            ? CoListSchema<T>
+            : S extends AnyCoFeedSchema<infer T>
+              ? CoFeedSchema<T>
+              : S extends AnyPlainTextSchema
+                ? PlainTextSchema
+                : S extends AnyRichTextSchema
+                  ? RichTextSchema
+                  : S extends AnyFileStreamSchema
+                    ? FileStreamSchema
+                    : S extends z.core.$ZodOptional<infer Inner>
+                      ? CoValueSchemaFromZodSchema<Inner>
+                      : S extends z.core.$ZodUnion<
+                            infer Members extends readonly [
+                              AnyDiscriminableCoSchema,
+                              ...AnyDiscriminableCoSchema[],
+                            ]
+                          >
+                        ? CoDiscriminatedUnionSchema<Members>
+                        : never
+    : never;
+
+export type CoValueClassFromAnySchema<S extends CoValueOrZodSchema> =
+  S extends CoValueClass<any>
+    ? S
+    : CoValueClass<InstanceOfSchema<S>> &
+        CoValueFromRaw<InstanceOfSchema<S>> &
+        (S extends AnyAccountSchema ? AccountClassEssentials : {});
 
 type AccountClassEssentials = {
   fromRaw: <A extends Account>(this: AccountClass<A>, raw: RawAccount) => A;
   fromNode: <A extends Account>(this: AccountClass<A>, node: LocalNode) => A;
 };
 
+// TODO rename to ProtoCoSchema?
 export type AnyCoSchema =
   | AnyCoMapSchema
   | AnyAccountSchema
@@ -87,9 +145,10 @@ export type AnyCoSchema =
   | AnyCoListSchema
   | AnyCoFeedSchema
   | AnyCoUnionSchema
-  | PlainTextSchema
-  | RichTextSchema
-  | FileStreamSchema;
+  | AnyCoOptionalSchema
+  | AnyPlainTextSchema
+  | AnyRichTextSchema
+  | AnyFileStreamSchema;
 
 export type Loaded<
   T extends CoValueClass | AnyCoSchema,

package/src/tools/internal.ts

@@ -33,6 +33,7 @@ export * from "./implementation/zodSchema/zodSchema.js";
 export * from "./implementation/zodSchema/zodCo.js";
 export * as co from "./implementation/zodSchema/coExport.js";
 export * from "./implementation/zodSchema/schemaTypes/CoMapSchema.js";
+export * from "./implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoRecordSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoListSchema.js";
 export * from "./implementation/zodSchema/schemaTypes/CoFeedSchema.js";

package/src/tools/subscribe/SubscriptionScope.ts

@@ -126,8 +126,7 @@ export class SubscriptionScope<D extends CoValue> {
           new JazzError(this.id, "unauthorized", [
             {
               code: "unauthorized",
-              message:
-                "The current user is not authorized to access this value",
+              message: `The current user (${this.node.getCurrentAgent().id}) is not authorized to access this value`,
               params: {
                 id: this.id,
               },

package/src/tools/tests/ContextManager.test.ts

@@ -4,13 +4,11 @@ import {
   Account,
   AccountClass,
   AuthSecretStorage,
-  CoMap,
   Group,
   InMemoryKVStore,
   JazzAuthContext,
   KvStoreContext,
   co,
-  coField,
   z,
 } from "../exports";
 import {
@@ -26,6 +24,7 @@ import {
   CoValueFromRaw,
   InstanceOfSchema,
   Loaded,
+  anySchemaToCoSchema,
   zodSchemaToCoSchema,
 } from "../internal";
 import {
@@ -258,7 +257,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = (
@@ -313,7 +312,7 @@ describe("ContextManager", () => {
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = (
@@ -339,7 +338,7 @@ describe("ContextManager", () => {
     const AccountRoot = co.map({
       value: z.string(),
       get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
-        return z.optional(AccountRoot);
+        return co.optional(AccountRoot);
       },
     });
 
@@ -385,7 +384,7 @@ describe("ContextManager", () => {
     // Create initial anonymous context
     await customManager.createContext({
       onAnonymousAccountDiscarded,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: anySchemaToCoSchema(CustomAccount),
     });
 
     const account = await createJazzTestAccount({