jazz-tools 0.15.10 → 0.15.11

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,
@@ -42,3 +48,26 @@ export {
   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/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({

package/src/tools/tests/coDiscriminatedUnion.test-d.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, test } from "vitest";
+import { Loaded, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+
+describe("co.discriminatedUnion", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("can use co.discriminatedUnion with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [Dog, Cat]),
+    });
+
+    const person = Person.create({
+      pet: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    person.pet = Cat.create({
+      type: "cat",
+    });
+
+    type ExpectedType = {
+      pet: Loaded<typeof Dog> | Loaded<typeof Cat>;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(person);
+  });
+
+  test("cannot use co.discriminatedUnion with zod schemas as values", () => {
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [
+        // @ts-expect-error: cannot use co.discriminatedUnion with a Zod schema
+        z.object({
+          type: z.string(),
+        }),
+      ]),
+    });
+  });
+});

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

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { Loaded, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { waitFor } from "./utils.js";
+
+describe("co.discriminatedUnion", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("use co.discriminatedUnion with CoValue schemas as values", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Person = co.map({
+      pet: co.discriminatedUnion("type", [Dog, Cat]),
+    });
+
+    const person = Person.create({
+      pet: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    expect(person.pet.type).toEqual("dog");
+
+    person.pet = Cat.create({
+      type: "cat",
+    });
+
+    expect(person.pet.type).toEqual("cat");
+  });
+
+  test("load CoValue instances using the DiscriminatedUnion schema", async () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({ type: "dog" });
+    const loadedPet = await Pet.load(dog.id);
+    expect(loadedPet?.type).toEqual("dog");
+  });
+
+  test("subscribe to CoValue instances using the DiscriminatedUnion schema", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      name: z.string(),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      name: z.string(),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      name: "Rex",
+      owner: Person.create({ name: "John Doe" }),
+    });
+
+    const updates: Loaded<typeof Pet>[] = [];
+    const spy = vi.fn((pet) => updates.push(pet));
+
+    Pet.subscribe(dog.id, {}, (pet) => {
+      expect(pet.type).toEqual("dog");
+      spy(pet);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    expect(updates[0]?.name).toEqual("Rex");
+  });
+});

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

@@ -1,15 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import {
-  Account,
-  CoList,
-  CoMap,
-  Group,
-  coField,
-  subscribeToCoValue,
-  z,
-} from "../index.js";
-import { Loaded, co, zodSchemaToCoSchema } from "../internal.js";
+import { Account, Group, subscribeToCoValue, z } from "../index.js";
+import { Loaded, anySchemaToCoSchema, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -127,7 +119,7 @@ describe("Simple CoList operations", async () => {
         name: z.string(),
       });
 
-      const Recipe = co.list(z.optional(Ingredient));
+      const Recipe = co.list(co.optional(Ingredient));
 
       const recipe = Recipe.create(
         [
@@ -588,7 +580,7 @@ describe("CoList subscription", async () => {
     const spy = vi.fn((list) => updates.push(list));
 
     subscribeToCoValue(
-      zodSchemaToCoSchema(TestList),
+      anySchemaToCoSchema(TestList),
       list.id,
       {
         syncResolution: true,

package/src/tools/tests/coMap.record.test.ts

@@ -281,7 +281,7 @@ describe("CoMap.Record", async () => {
     });
 
     test("Is ok to omit optional fields", () => {
-      const TestRecord = co.record(z.string(), z.optional(NestedRecord));
+      const TestRecord = co.record(z.string(), co.optional(NestedRecord));
 
       expectTypeOf<typeof TestRecord.create>().toBeCallableWith(
         {
@@ -315,7 +315,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({
@@ -350,7 +350,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({
@@ -385,7 +385,7 @@ describe("CoMap.Record", async () => {
 
     const PersonRecord = co.record(
       z.string(),
-      z.discriminatedUnion("type", [Base, IssueRepro]),
+      co.discriminatedUnion("type", [Base, IssueRepro]),
     );
 
     const person = IssueRepro.create({

package/src/tools/tests/coMap.test-d.ts

@@ -159,7 +159,7 @@ describe("CoMap", async () => {
     test("Comap with recursive optional reference", () => {
       const Recursive = co.map({
         get child(): z.ZodOptional<typeof Recursive> {
-          return z.optional(Recursive);
+          return co.optional(Recursive);
         },
       });
 
@@ -185,7 +185,7 @@ describe("CoMap", async () => {
         age: z.number(),
         // TODO: would be nice if this didn't need a type annotation
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -280,7 +280,7 @@ describe("CoMap", async () => {
 
     const MapWithEnumOfMaps = co.map({
       name: z.string(),
-      child: z.discriminatedUnion("type", [ChildA, ChildB]),
+      child: co.discriminatedUnion("type", [ChildA, ChildB]),
     });
 
     const mapWithEnum = MapWithEnumOfMaps.create({

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

@@ -12,7 +12,7 @@ import {
 } from "vitest";
 import { Group, co, subscribeToCoValue, z } from "../exports.js";
 import { Account } from "../index.js";
-import { ID, Loaded, zodSchemaToCoSchema } from "../internal.js";
+import { Loaded, anySchemaToCoSchema } from "../internal.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -145,7 +145,7 @@ describe("CoMap", async () => {
         age: z.number(),
         // TODO: would be nice if this didn't need a type annotation
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -182,7 +182,7 @@ describe("CoMap", async () => {
         name: z.string(),
         age: z.number(),
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -211,7 +211,7 @@ describe("CoMap", async () => {
         name: z.string(),
         age: z.number(),
         get friend(): z.ZodOptional<typeof Person> {
-          return z.optional(Person);
+          return co.optional(Person);
         },
       });
 
@@ -400,7 +400,7 @@ describe("CoMap", async () => {
 
     const MapWithEnumOfMaps = co.map({
       name: z.string(),
-      child: z.discriminatedUnion("type", [ChildA, ChildB]),
+      child: co.discriminatedUnion("type", [ChildA, ChildB]),
     });
 
     const mapWithEnum = MapWithEnumOfMaps.create({
@@ -801,7 +801,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     subscribeToCoValue(
-      zodSchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
+      anySchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
       person.id,
       {
         syncResolution: true,
@@ -1003,7 +1003,7 @@ describe("CoMap applyDiff", async () => {
     birthday: z.date(),
     nested: NestedMap,
     optionalField: z.string().optional(),
-    optionalNested: z.optional(NestedMap),
+    optionalNested: co.optional(NestedMap),
   });
 
   test("Basic applyDiff", () => {
@@ -1698,7 +1698,7 @@ describe("Creating and finding unique CoMaps", async () => {
       dateValue: z.date(),
     });
 
-    const AttributeValue = z.discriminatedUnion("type", [
+    const AttributeValue = co.discriminatedUnion("type", [
       StringAttributeValue,
       NumberAttributeValue,
       DateAttributeValue,
@@ -1714,7 +1714,7 @@ describe("Creating and finding unique CoMaps", async () => {
       attributeValue: AttributeValue,
     });
 
-    const Tag = z.discriminatedUnion("type", [
+    const Tag = co.discriminatedUnion("type", [
       AttributeTag,
       StringTag,
       DateTag,
@@ -1764,7 +1764,7 @@ describe("Creating and finding unique CoMaps", async () => {
       error: HttpError,
     });
 
-    const ErrorResponse = z.discriminatedUnion("type", [
+    const ErrorResponse = co.discriminatedUnion("type", [
       ClientError,
       ServerError,
       NetworkError,

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

@@ -0,0 +1,39 @@
+import { beforeEach, describe, test } from "vitest";
+import { CoPlainText, co, z } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+
+describe("co.optional", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  test("can use co.optional with CoValue schemas as values", () => {
+    const Person = co.map({
+      preferredName: co.optional(co.plainText()),
+    });
+
+    const person = Person.create({});
+
+    type ExpectedType = {
+      preferredName?: CoPlainText;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(person);
+  });
+
+  test("cannot use co.optional with zod schemas as values", () => {
+    const Person = co.map({
+      // @ts-expect-error: cannot use co.optional with a Zod schema
+      preferredName: co.optional(z.string()),
+    });
+  });
+});

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

@@ -1,4 +1,4 @@
-import { AgentSecret, RawCoMap } from "cojson";
+import { AgentSecret } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import {
@@ -9,6 +9,7 @@ import {
   ID,
   InMemoryKVStore,
   KvStoreContext,
+  anySchemaToCoSchema,
   co,
   createAnonymousJazzContext,
   createJazzContext,
@@ -90,7 +91,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
 
@@ -199,7 +200,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
 
@@ -350,7 +351,7 @@ describe("createContext methods", () => {
       });
 
       expect(context.account).toBeInstanceOf(
-        zodSchemaToCoSchema(CustomAccount),
+        anySchemaToCoSchema(CustomAccount),
       );
     });
   });