jazz-tools 0.15.15 → 0.16.0

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

@@ -4,8 +4,8 @@ import {
   Account,
   CryptoProvider,
   Loaded,
-  anySchemaToCoSchema,
   co,
+  coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
   z,
 } from "../exports.js";
@@ -93,7 +93,7 @@ describe("SchemaUnion", () => {
     );
     let currentValue = "Submit";
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(WidgetUnion),
+      coValueClassFromCoValueClassOrSchema(WidgetUnion),
       buttonWidget.id,
       { loadAs: me, syncResolution: true },
       (value: Loaded<typeof WidgetUnion>) => {

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

@@ -10,9 +10,8 @@ import {
 import { Account, Group, cojsonInternals, z } from "../index.js";
 import {
   Loaded,
-  anySchemaToCoSchema,
   co,
-  createCoValueObservable,
+  coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
 } from "../internal.js";
 import {
@@ -70,7 +69,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, true> | null;
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       { loadAs: meOnSecondPeer },
       (value) => {
@@ -117,7 +116,7 @@ describe("subscribeToCoValue", () => {
     let result = null as Loaded<typeof ChatRoom, {}> | null;
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -158,7 +157,7 @@ describe("subscribeToCoValue", () => {
     messages.push(createMessage(me, "Hello"));
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -201,7 +200,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -261,7 +260,7 @@ describe("subscribeToCoValue", () => {
     >[];
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -332,7 +331,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(ChatRoom),
+      coValueClassFromCoValueClassOrSchema(ChatRoom),
       chatRoom.id,
       {
         loadAs: meOnSecondPeer,
@@ -396,7 +395,7 @@ describe("subscribeToCoValue", () => {
     const updateFn = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: account,
@@ -457,7 +456,7 @@ describe("subscribeToCoValue", () => {
     const onUnauthorized = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -528,7 +527,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -603,7 +602,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -673,7 +672,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -725,7 +724,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -792,7 +791,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: creator,
@@ -881,7 +880,7 @@ describe("subscribeToCoValue", () => {
     });
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(Person),
+      coValueClassFromCoValueClassOrSchema(Person),
       person.id,
       {
         loadAs: reader,
@@ -968,7 +967,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         loadAs: reader,
@@ -1055,7 +1054,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(PersonList),
+      coValueClassFromCoValueClassOrSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1151,7 +1150,7 @@ describe("subscribeToCoValue", () => {
     const onUnavailable = vi.fn();
 
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(PersonList),
+      coValueClassFromCoValueClassOrSchema(PersonList),
       list.id,
       {
         loadAs: reader,
@@ -1188,13 +1187,14 @@ describe("subscribeToCoValue", () => {
   it("should subscribe to a large coValue", async () => {
     const syncServer = await setupJazzTestSync({ asyncPeers: true });
 
+    const Data = co.list(z.string());
     const LargeDataset = co.map({
       metadata: z.object({
         name: z.string(),
         description: z.string(),
         createdAt: z.number(),
       }),
-      data: co.list(z.string()),
+      data: Data,
     });
 
     const group = Group.create(syncServer);
@@ -1206,7 +1206,7 @@ describe("subscribeToCoValue", () => {
             "A dataset with many entries for testing large coValue subscription",
           createdAt: Date.now(),
         },
-        data: LargeDataset.def.shape.data.create([], group),
+        data: Data.create([], group),
       },
       group,
     );
@@ -1234,7 +1234,7 @@ describe("subscribeToCoValue", () => {
 
     // Test subscribing to the large coValue
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(LargeDataset),
+      coValueClassFromCoValueClassOrSchema(LargeDataset),
       largeMap.id,
       {
         loadAs: alice,
@@ -1277,95 +1277,3 @@ describe("subscribeToCoValue", () => {
     expect(result.data[chunks]).toBe("new entry");
   });
 });
-
-describe("createCoValueObservable", () => {
-  const TestMap = co.map({
-    color: z.string(),
-  });
-
-  function createTestMap(me: Account | Group) {
-    return TestMap.create({ color: "red" }, { owner: me });
-  }
-
-  it("should return undefined when there are no subscribers", async () => {
-    const observable = createCoValueObservable();
-
-    expect(observable.getCurrentValue()).toBeUndefined();
-  });
-
-  it("should update currentValue when subscribed", async () => {
-    const { me, meOnSecondPeer } = await setupAccount();
-    const testMap = createTestMap(me);
-    const observable = createCoValueObservable();
-    const mockListener = vi.fn();
-
-    const unsubscribe = observable.subscribe(
-      anySchemaToCoSchema(TestMap),
-      testMap.id,
-      {
-        loadAs: meOnSecondPeer,
-      },
-      () => {
-        mockListener();
-      },
-    );
-
-    testMap.color = "blue";
-
-    await waitFor(() => mockListener.mock.calls.length > 0);
-
-    expect(observable.getCurrentValue()).toMatchObject({
-      id: testMap.id,
-      color: "blue",
-    });
-
-    unsubscribe();
-  });
-
-  it("should reset to undefined after unsubscribe", async () => {
-    const { me, meOnSecondPeer } = await setupAccount();
-    const testMap = createTestMap(me);
-    const observable = createCoValueObservable();
-    const mockListener = vi.fn();
-
-    const unsubscribe = observable.subscribe(
-      anySchemaToCoSchema(TestMap),
-      testMap.id,
-      {
-        loadAs: meOnSecondPeer,
-      },
-      () => {
-        mockListener();
-      },
-    );
-
-    await waitFor(() => mockListener.mock.calls.length > 0);
-    expect(observable.getCurrentValue()).toBeDefined();
-
-    unsubscribe();
-    expect(observable.getCurrentValue()).toBeUndefined();
-  });
-
-  it("should return null if the coValue is not found", async () => {
-    const { meOnSecondPeer } = await setupAccount();
-    const observable = createCoValueObservable<
-      typeof TestMap,
-      Loaded<typeof TestMap, {}>
-    >();
-
-    const unsubscribe = observable.subscribe(
-      TestMap,
-      "co_z123",
-      { loadAs: meOnSecondPeer },
-      () => {},
-    );
-
-    expect(observable.getCurrentValue()).toBeUndefined();
-
-    await waitFor(() => {
-      expect(observable.getCurrentValue()).toBeNull();
-    });
-
-    unsubscribe();
-  });
-});

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,

package/tsup.config.ts

@@ -73,8 +73,6 @@ export default defineConfig([
   {
     ...cfg,
     entry: {
-      index: "src/react/index.ts",
-      testing: "src/react/testing.tsx",
       ssr: "src/react/ssr.ts",
     },
     outDir: "dist/react",