jazz-tools 0.15.16 → 0.16.0

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

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test } from "vitest";
-import { Account, CoMap, Group, co, z, zodSchemaToCoSchema } from "../exports";
+import { Account, CoMap, Group, co, z } from "../exports";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing";
 
 describe("Jazz Test Sync", () => {
@@ -43,7 +43,7 @@ describe("Jazz Test Sync", () => {
       });
 
     const account1 = await createJazzTestAccount({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
       isCurrentActiveAccount: true,
     });
 
@@ -69,12 +69,12 @@ describe("Jazz Test Sync", () => {
       });
 
     const account1 = await createJazzTestAccount({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
       isCurrentActiveAccount: true,
     });
 
     const account2 = await createJazzTestAccount({
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
       isCurrentActiveAccount: false,
     });
 
@@ -91,11 +91,11 @@ describe("Jazz Test Sync", () => {
 
     const promise = Promise.all([
       createJazzTestAccount({
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
         isCurrentActiveAccount: true,
       }),
       createJazzTestAccount({
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
         isCurrentActiveAccount: true,
       }),
     ]);

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

@@ -15,6 +15,33 @@ describe("CoValue and Zod schema compatibility", () => {
     });
   });
 
+  test("cannot use z.optional with CoValue schemas", () => {
+    const Dog = co.map({
+      name: z.string(),
+      breed: z.string(),
+    });
+
+    const Person = co.map({
+      // @ts-expect-error: cannot use z.optional with a CoValue schema
+      pet: z.optional(Dog),
+    });
+  });
+
+  test("cannot use z.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({
+      // @ts-expect-error: cannot use z.discriminatedUnion with a CoValue schema
+      pets: z.discriminatedUnion("type", [Dog, Cat]),
+    });
+  });
+
   test("cannot use z.union with CoValue schemas as values", () => {
     const Dog = co.map({
       type: z.literal("dog"),

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

@@ -368,51 +368,6 @@ describe("co.map and Zod schema compatibility", () => {
     //   expect(failedMap.result).toEqual({ status: "failed", error: "error" });
     // });
 
-    it("should handle discriminated unions of CoValues", () => {
-      const Dog = co.map({
-        type: z.literal("dog"),
-        breed: z.string(),
-      });
-
-      const Cat = co.map({
-        type: z.literal("cat"),
-        name: z.string(),
-      });
-
-      const Person = co.map({
-        pet: z.discriminatedUnion("type", [Dog, Cat]),
-      });
-
-      const person = Person.create({
-        pet: Dog.create({ type: "dog", breed: "Labrador" }),
-      });
-
-      expect(person.pet).toEqual({ type: "dog", breed: "Labrador" });
-
-      person.pet = Cat.create({ type: "cat", name: "Whiskers" });
-
-      expect(person.pet).toEqual({ type: "cat", name: "Whiskers" });
-    });
-
-    it("should handle optional CoValues", () => {
-      const Dog = co.map({
-        name: z.string(),
-        breed: z.string(),
-      });
-
-      const Person = co.map({
-        pet: z.optional(Dog),
-      });
-
-      const person = Person.create({});
-
-      expect(person.pet).toBeUndefined();
-
-      person.pet = Dog.create({ name: "Rex", breed: "Labrador" });
-
-      expect(person.pet).toEqual({ name: "Rex", breed: "Labrador" });
-    });
-
     // it("should handle intersections", async () => {
     //   const schema = co.map({
     //     value: z.intersection(
@@ -503,3 +458,53 @@ describe("co.map and Zod schema compatibility", () => {
     });
   });
 });
+
+describe("z.object() and CoValue schema compatibility", () => {
+  it("z.object() should throw an error when used with CoValue schema values", () => {
+    const coValueSchema = co.map({});
+    expect(() => z.object({ value: coValueSchema })).toThrow(
+      "z.object() does not support collaborative types as values. Use co.map() instead",
+    );
+  });
+
+  it("z.strictObject() should throw an error when used with CoValue schema values", () => {
+    const coValueSchema = co.map({});
+    expect(() => z.strictObject({ value: coValueSchema })).toThrow(
+      "z.strictObject() does not support collaborative types as values. Use co.map() instead",
+    );
+  });
+
+  it("z.object() should continue to work with cyclic references", () => {
+    const NoteItem = z.object({
+      type: z.literal("note"),
+      content: z.string(),
+    });
+
+    const ReferenceItem = z.object({
+      type: z.literal("reference"),
+      content: z.string(),
+
+      get child(): z.ZodDiscriminatedUnion<
+        [typeof NoteItem, typeof ReferenceItem]
+      > {
+        return ProjectContextItem;
+      },
+    });
+
+    const ProjectContextItem = z.discriminatedUnion("type", [
+      NoteItem,
+      ReferenceItem,
+    ]);
+
+    const referenceItem = ReferenceItem.parse({
+      type: "reference",
+      content: "Hello",
+      child: {
+        type: "note",
+        content: "Hello",
+      },
+    });
+
+    expect(referenceItem.child.type).toEqual("note");
+  });
+});

package/src/worker/index.ts

@@ -7,7 +7,6 @@ import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import {
   Account,
   AccountClass,
-  AccountSchema,
   AnyAccountSchema,
   CoValueFromRaw,
   Inbox,