jazz-tools 0.13.31 → 0.14.1

package/src/tests/patterns/requestToJoin.test.ts

@@ -1,27 +1,26 @@
 import { assert, describe, expect, test } from "vitest";
-import { Account, CoList, CoMap, Group, ID, co } from "../../exports";
+import { Account, CoList, CoMap, Group, ID, co, z } from "../../exports";
 import { createJazzTestAccount, linkAccounts } from "../../testing";
 
-class RequestToJoin extends CoMap {
-  account = co.ref(Account);
-  status = co.literal("pending", "approved", "rejected");
-}
-
-class ProjectsList extends CoList.Of(co.string) {}
+const RequestToJoin = co.map({
+  account: Account,
+  status: z.literal(["pending", "approved", "rejected"]),
+});
 
-class RequestsMap extends CoMap.Record(co.ref(RequestToJoin)) {}
+const RequestsMap = co.record(z.string(), RequestToJoin);
 
-class RequestsStatus extends CoMap.Record(
-  co.literal("pending", "approved", "rejected"),
-) {}
+const RequestsStatus = co.record(
+  z.string(),
+  z.literal(["pending", "approved", "rejected"]),
+);
 
-class Organization extends CoMap {
-  name = co.string;
-  requests = co.ref(RequestsMap);
-  statuses = co.ref(RequestsStatus);
-  projects = co.ref(ProjectsList);
-  mainGroup = co.ref(Group);
-}
+const Organization = co.map({
+  name: z.string(),
+  requests: RequestsMap,
+  statuses: RequestsStatus,
+  projects: co.list(z.string()),
+  mainGroup: Group,
+});
 
 async function setup() {
   const admin1 = await createJazzTestAccount();
@@ -57,7 +56,7 @@ async function setup() {
       requests: RequestsMap.create({}, requestsGroup),
 
       // To simulate the resource to share
-      projects: ProjectsList.create([], organizationGroup),
+      projects: co.list(z.string()).create([], organizationGroup),
 
       // Statuses are private to admins
       // Used to make the requests statues readable only to them
@@ -83,10 +82,7 @@ async function setup() {
   };
 }
 
-async function sendRequestToJoin(
-  organizationId: ID<Organization>,
-  account: Account,
-) {
+async function sendRequestToJoin(organizationId: string, account: Account) {
   const organization = await Organization.load(organizationId, {
     resolve: { requests: true },
     loadAs: account,
@@ -112,7 +108,7 @@ async function sendRequestToJoin(
 }
 
 async function approveRequest(
-  organizationId: ID<Organization>,
+  organizationId: string,
   admin: Account,
   user: Account,
 ) {
@@ -147,7 +143,7 @@ async function approveRequest(
 }
 
 async function rejectRequest(
-  organizationId: ID<Organization>,
+  organizationId: string,
   admin: Account,
   user: Account,
 ) {
@@ -198,9 +194,11 @@ describe("Request to join", () => {
 
     await approveRequest(organizationId, admin1, user1);
 
-    const projectsOnUser = await ProjectsList.load(organization.projects.id, {
-      loadAs: user1,
-    });
+    const projectsOnUser = await co
+      .list(z.string())
+      .load(organization.projects.id, {
+        loadAs: user1,
+      });
 
     assert(projectsOnUser);
 
@@ -226,9 +224,11 @@ describe("Request to join", () => {
     await sendRequestToJoin(organizationId, user1);
     await rejectRequest(organizationId, admin1, user1);
 
-    const projectsOnUser = await ProjectsList.load(organization.projects.id, {
-      loadAs: user1,
-    });
+    const projectsOnUser = await co
+      .list(z.string())
+      .load(organization.projects.id, {
+        loadAs: user1,
+      });
 
     expect(projectsOnUser).toBeNull();
   });

package/src/tests/schema.test.ts

@@ -1,19 +1,18 @@
 import { describe, expectTypeOf, it } from "vitest";
-import { CoMap, co } from "../index.js";
-import { co as valueWithCoMarker } from "../internal.js";
+import { CoMap, coField } from "../index.js";
 
-describe("co.json TypeScript validation", () => {
+describe("coField.json TypeScript validation", () => {
   it("should accept serializable types", async () => {
     type ValidType = { str: string; num: number; bool: boolean };
 
     class ValidPrimitiveMap extends CoMap {
-      data = co.json<ValidType>();
+      data = coField.json<ValidType>();
     }
 
     expectTypeOf(ValidPrimitiveMap.create<ValidPrimitiveMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<ValidType>;
+        data: ValidType;
       }>();
   });
 
@@ -27,13 +26,13 @@ describe("co.json TypeScript validation", () => {
     };
 
     class ValidNestedMap extends CoMap {
-      data = co.json<NestedType>();
+      data = coField.json<NestedType>();
     }
 
     expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<NestedType>;
+        data: NestedType;
       }>();
   });
 
@@ -44,13 +43,13 @@ describe("co.json TypeScript validation", () => {
     };
 
     class ValidMap extends CoMap {
-      data = co.json<TypeWithOptional>();
+      data = coField.json<TypeWithOptional>();
     }
 
     expectTypeOf(ValidMap.create<ValidMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<TypeWithOptional>;
+        data: TypeWithOptional;
       }>();
   });
 
@@ -66,13 +65,13 @@ describe("co.json TypeScript validation", () => {
     }
 
     class ValidNestedMap extends CoMap {
-      data = co.json<NestedInterface>();
+      data = coField.json<NestedInterface>();
     }
 
     expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<NestedInterface>;
+        data: NestedInterface;
       }>();
   });
 
@@ -83,13 +82,13 @@ describe("co.json TypeScript validation", () => {
     }
 
     class ValidArrayMap extends CoMap {
-      data = co.json<ArrayInterface>();
+      data = coField.json<ArrayInterface>();
     }
 
     expectTypeOf(ValidArrayMap.create<ValidArrayMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<ArrayInterface>;
+        data: ArrayInterface;
       }>();
   });
 
@@ -100,13 +99,13 @@ describe("co.json TypeScript validation", () => {
 
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<InvalidInterface>();
+      data = coField.json<InvalidInterface>();
     }
 
     expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<InvalidInterface>;
+        data: InvalidInterface;
       }>();
   });
 
@@ -115,13 +114,13 @@ describe("co.json TypeScript validation", () => {
 
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<InvalidType>();
+      data = coField.json<InvalidType>();
     }
 
     expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<InvalidType>;
+        data: InvalidType;
       }>();
   });
 
@@ -130,13 +129,13 @@ describe("co.json TypeScript validation", () => {
 
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<InvalidType>();
+      data = coField.json<InvalidType>();
     }
 
     expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<InvalidType>;
+        data: InvalidType;
       }>();
   });
 
@@ -145,7 +144,7 @@ describe("co.json TypeScript validation", () => {
 
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<InvalidType>();
+      data = coField.json<InvalidType>();
     }
   });
 
@@ -159,16 +158,16 @@ describe("co.json TypeScript validation", () => {
     };
 
     class MapWithOptionalJSON extends CoMap {
-      data = co.optional.json<ValidType>();
+      data = coField.optional.json<ValidType>();
       // @ts-expect-error Should not be considered valid
-      data2 = co.optional.json<InvalidType>();
+      data2 = coField.optional.json<InvalidType>();
     }
 
     expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
       .parameter(0)
       .toEqualTypeOf<{
-        data?: valueWithCoMarker<ValidType> | null;
-        data2?: valueWithCoMarker<InvalidType> | null;
+        data?: ValidType | null;
+        data2?: InvalidType | null;
       }>();
   });
 
@@ -188,58 +187,58 @@ describe("co.json TypeScript validation", () => {
     }
 
     class MapWithOptionalJSON extends CoMap {
-      data1 = co.optional.json<ValidInterface0>();
-      data2 = co.optional.json<ValidInterface1>();
-      data3 = co.optional.json<InterfaceWithOptionalTypes>();
+      data1 = coField.optional.json<ValidInterface0>();
+      data2 = coField.optional.json<ValidInterface1>();
+      data3 = coField.optional.json<InterfaceWithOptionalTypes>();
     }
 
     expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
       .parameter(0)
       .toEqualTypeOf<{
-        data1?: valueWithCoMarker<ValidInterface0> | null;
-        data2?: valueWithCoMarker<ValidInterface1> | null;
-        data3?: valueWithCoMarker<InterfaceWithOptionalTypes> | null;
+        data1?: ValidInterface0 | null;
+        data2?: ValidInterface1 | null;
+        data3?: InterfaceWithOptionalTypes | null;
       }>();
   });
 
   it("should not accept functions", async () => {
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<() => void>();
+      data = coField.json<() => void>();
     }
   });
 
   it("should not accept functions in nested properties", async () => {
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<{ func: () => void }>();
+      data = coField.json<{ func: () => void }>();
     }
   });
 
   it("should not accept RegExp", async () => {
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
-      data = co.json<RegExp>();
+      data = coField.json<RegExp>();
     }
 
     expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        data: valueWithCoMarker<RegExp>;
+        data: RegExp;
       }>();
   });
 
   it("should accept strings and numbers", async () => {
     class InvalidFunctionMap extends CoMap {
-      str = co.json<string>();
-      num = co.json<number>();
+      str = coField.json<string>();
+      num = coField.json<number>();
     }
 
     expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
       .parameter(0)
       .toEqualTypeOf<{
-        str: valueWithCoMarker<string>;
-        num: valueWithCoMarker<number>;
+        str: string;
+        num: number;
       }>();
   });
 });

package/src/tests/schemaUnion.test.ts

@@ -1,67 +1,47 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { beforeAll, describe, expect, it } from "vitest";
-import { SchemaUnion } from "../coValues/schemaUnion.js";
+import { assert, beforeAll, describe, expect, it } from "vitest";
 import {
   Account,
-  CoMap,
   CryptoProvider,
+  Loaded,
   co,
   loadCoValue,
   subscribeToCoValue,
+  z,
+  zodSchemaToCoSchema,
 } from "../exports.js";
 
-class BaseWidget extends CoMap {
-  type = co.string;
-}
-
-class RedButtonWidget extends BaseWidget {
-  type = co.literal("button");
-  color = co.literal("red");
-  label = co.string;
-}
-
-class BlueButtonWidget extends BaseWidget {
-  type = co.literal("button");
-  color = co.literal("blue");
-  label = co.string;
-}
+const RedButtonWidget = co.map({
+  type: z.literal("button"),
+  color: z.literal("red"),
+  label: z.string(),
+});
 
-const ButtonWidget = SchemaUnion.Of<BaseWidget>((raw) => {
-  switch (raw.get("color")) {
-    case "red":
-      return RedButtonWidget;
-    case "blue":
-      return BlueButtonWidget;
-    default:
-      throw new Error(`Unknown button color: ${raw.get("color")}`);
-  }
+const BlueButtonWidget = co.map({
+  type: z.literal("button"),
+  color: z.literal("blue"),
+  label: z.string(),
+  blueness: z.number(),
 });
 
-class SliderWidget extends BaseWidget {
-  type = co.literal("slider");
-  min = co.number;
-  max = co.number;
-}
+const ButtonWidget = z.discriminatedUnion([RedButtonWidget, BlueButtonWidget]);
 
-class CheckboxWidget extends BaseWidget {
-  type = co.literal("checkbox");
-  checked = co.boolean;
-}
+const SliderWidget = co.map({
+  type: z.literal("slider"),
+  min: z.number(),
+  max: z.number(),
+});
 
-const getWidgetSchemaFromRaw = (raw: BaseWidget["_raw"]) => {
-  switch (raw.get("type")) {
-    case "button":
-      return ButtonWidget;
-    case "slider":
-      return SliderWidget;
-    case "checkbox":
-      return CheckboxWidget;
-    default:
-      throw new Error(`Unknown widget type: ${raw.get("type")}`);
-  }
-};
+const CheckboxWidget = co.map({
+  type: z.literal("checkbox"),
+  checked: z.boolean(),
+});
 
-class WidgetUnion extends SchemaUnion.Of<BaseWidget>(getWidgetSchemaFromRaw) {}
+const WidgetUnion = z.discriminatedUnion([
+  ButtonWidget,
+  SliderWidget,
+  CheckboxWidget,
+]);
 
 describe("SchemaUnion", () => {
   let Crypto: CryptoProvider;
@@ -75,7 +55,7 @@ describe("SchemaUnion", () => {
     });
   });
 
-  it("should instantiate the correct subclass based on schema and provided data", async () => {
+  it("should instantiate the correct schema based on schema and provided data", async () => {
     const buttonWidget = RedButtonWidget.create(
       { type: "button", color: "red", label: "Submit" },
       { owner: me },
@@ -89,36 +69,46 @@ describe("SchemaUnion", () => {
       { owner: me },
     );
 
-    const loadedButtonWidget = await loadCoValue(WidgetUnion, buttonWidget.id, {
-      loadAs: me,
-    });
-    const loadedSliderWidget = await loadCoValue(WidgetUnion, sliderWidget.id, {
-      loadAs: me,
-    });
+    const loadedButtonWidget = await loadCoValue(
+      zodSchemaToCoSchema(WidgetUnion),
+      buttonWidget.id,
+      {
+        loadAs: me,
+      },
+    );
+    const loadedSliderWidget = await loadCoValue(
+      zodSchemaToCoSchema(WidgetUnion),
+      sliderWidget.id,
+      {
+        loadAs: me,
+      },
+    );
     const loadedCheckboxWidget = await loadCoValue(
-      WidgetUnion,
+      zodSchemaToCoSchema(WidgetUnion),
       checkboxWidget.id,
       { loadAs: me },
     );
 
-    expect(loadedButtonWidget).toBeInstanceOf(RedButtonWidget);
-    expect(loadedSliderWidget).toBeInstanceOf(SliderWidget);
-    expect(loadedCheckboxWidget).toBeInstanceOf(CheckboxWidget);
+    expect(loadedButtonWidget?.type).toBe("button");
+    expect(loadedSliderWidget?.type).toBe("slider");
+    expect(loadedCheckboxWidget?.type).toBe("checkbox");
   });
 
   it("should integrate with subscribeToCoValue correctly", async () => {
     const buttonWidget = BlueButtonWidget.create(
-      { type: "button", color: "blue", label: "Submit" },
+      { type: "button", color: "blue", label: "Submit", blueness: 100 },
       { owner: me },
     );
     let currentValue = "Submit";
     const unsubscribe = subscribeToCoValue(
-      WidgetUnion,
+      zodSchemaToCoSchema(WidgetUnion),
       buttonWidget.id,
       { loadAs: me, syncResolution: true },
-      (value: BaseWidget) => {
-        if (value instanceof BlueButtonWidget) {
+      (value: Loaded<typeof WidgetUnion>) => {
+        if (value.type === "button") {
           expect(value.label).toBe(currentValue);
+          assert(value.color === "blue");
+          expect(value.blueness).toBe(100);
         } else {
           throw new Error("Unexpected widget type");
         }