jazz-tools 0.15.16 → 0.16.0

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

@@ -1,5 +1,5 @@
 import { assert, beforeEach, expect, test } from "vitest";
-import { Account, CoListSchema, Group, co, z } from "../exports.js";
+import { Account, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
   linkAccounts,
@@ -147,10 +147,10 @@ test("should support recursive props on co.profile", async () => {
     username: z.optional(z.string()),
     display_name: z.optional(z.string()),
     anonymous: z.boolean(),
-    get following(): CoListSchema<typeof User> {
+    get following(): co.List<typeof User> {
       return co.list(User);
     },
-    get followers(): CoListSchema<typeof User> {
+    get followers(): co.List<typeof User> {
       return co.list(User);
     },
   });
@@ -194,3 +194,65 @@ test("should support recursive props on co.profile", async () => {
   expect(account.profile.following.length).toBe(0);
   expect(account.profile.followers.length).toBe(0);
 });
+
+test("root and profile should be trusting by default", async () => {
+  const AccountSchema = co
+    .account({
+      profile: co.profile(),
+      root: co.map({
+        name: z.string(),
+      }),
+    })
+    .withMigration((me, creationProps) => {
+      const group = Group.create({ owner: me }).makePublic();
+
+      if (me.profile === undefined) {
+        me.profile = co.profile().create(
+          {
+            name: creationProps?.name ?? "Anonymous",
+          },
+          group,
+        );
+      }
+
+      if (me.root === undefined) {
+        me.root = co
+          .map({
+            name: z.string(),
+          })
+          .create(
+            {
+              name: creationProps?.name ?? "Anonymous",
+            },
+            group,
+          );
+      }
+    });
+
+  const bob = await createJazzTestAccount({
+    AccountSchema,
+    creationProps: {
+      name: "Bob",
+    },
+  });
+
+  const alice = await createJazzTestAccount({
+    AccountSchema,
+    creationProps: {
+      name: "Alice",
+    },
+  });
+
+  const bobAccountLoadedFromAlice = await AccountSchema.load(bob.id, {
+    loadAs: alice,
+    resolve: {
+      profile: true,
+      root: true,
+    },
+  });
+
+  assert(bobAccountLoadedFromAlice);
+
+  expect(bobAccountLoadedFromAlice.profile.name).toBe("Bob");
+  expect(bobAccountLoadedFromAlice.root.name).toBe("Bob");
+});

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

@@ -44,6 +44,44 @@ describe("co.discriminatedUnion", () => {
     matches(person);
   });
 
+  test("recursive co.discriminatedUnion", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+      get friend() {
+        return co.optional(Pet);
+      },
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      get friend() {
+        return co.optional(Pet);
+      },
+    });
+
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const pallino = Cat.create({
+      type: "cat",
+      friend: Dog.create({
+        type: "dog",
+      }),
+    });
+
+    pallino.friend = Cat.create({
+      type: "cat",
+    });
+
+    type ExpectedType = {
+      friend: Loaded<typeof Dog> | Loaded<typeof Cat> | undefined;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(pallino);
+  });
+
   test("cannot use co.discriminatedUnion with zod schemas as values", () => {
     const Person = co.map({
       pet: co.discriminatedUnion("type", [

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

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import { Loaded, co, z } from "../exports.js";
+import { CoPlainText, Loaded, co, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -39,6 +39,224 @@ describe("co.discriminatedUnion", () => {
     expect(person.pet.type).toEqual("cat");
   });
 
+  test("use nested co.discriminatedUnions", () => {
+    const BaseError = { status: z.literal("failed"), message: z.string() };
+    const BadRequestError = co.map({ ...BaseError, code: z.literal(400) });
+    const UnauthorizedError = co.map({ ...BaseError, code: z.literal(401) });
+    const InternalServerError = co.map({ ...BaseError, code: z.literal(500) });
+    const Errors = co.discriminatedUnion("code", [
+      BadRequestError,
+      UnauthorizedError,
+      InternalServerError,
+    ]);
+
+    const Success = co.map({ status: z.literal("success"), data: z.string() });
+    const Response = co.map({
+      result: co.discriminatedUnion("status", [Success, Errors]),
+    });
+
+    const response = Response.create({
+      result: Success.create({
+        status: "success",
+        data: "Hello, world!",
+      }),
+    });
+
+    expect(response.result.status).toEqual("success");
+    if (response.result.status === "success") {
+      expect(response.result.data).toEqual("Hello, world!");
+    }
+
+    response.result = BadRequestError.create({
+      status: "failed",
+      message: "Bad request",
+      code: 400,
+    });
+
+    expect(response.result.status).toEqual("failed");
+    if (response.result.status === "failed") {
+      expect(response.result.code).toEqual(400);
+      if (response.result.code === 400) {
+        expect(response.result.message).toEqual("Bad request");
+      }
+    }
+  });
+
+  test("use deeply nested co.discriminatedUnions", () => {
+    const BaseError = { status: z.literal("failed"), message: z.string() };
+    const BadRequestError = co.map({ ...BaseError, code: z.literal(400) });
+    const UnauthorizedError = co.map({ ...BaseError, code: z.literal(401) });
+    const Errors = co.discriminatedUnion("code", [
+      BadRequestError,
+      co.discriminatedUnion("code", [
+        co.discriminatedUnion("code", [
+          co.discriminatedUnion("code", [UnauthorizedError]),
+        ]),
+      ]),
+    ]);
+
+    const Response = co.map({
+      error: Errors,
+    });
+
+    const response = Response.create({
+      error: BadRequestError.create({
+        status: "failed",
+        message: "Bad request",
+        code: 400,
+      }),
+    });
+
+    expect(response.error.status).toEqual("failed");
+    if (response.error.status === "failed") {
+      expect(response.error.code).toEqual(400);
+      if (response.error.code === 400) {
+        expect(response.error.message).toEqual("Bad request");
+      }
+    }
+
+    response.error = UnauthorizedError.create({
+      status: "failed",
+      message: "Unauthorized",
+      code: 401,
+    });
+
+    expect(response.error.status).toEqual("failed");
+    if (response.error.status === "failed") {
+      expect(response.error.code).toEqual(401);
+      if (response.error.code === 401) {
+        expect(response.error.message).toEqual("Unauthorized");
+      }
+    }
+  });
+
+  test("co.discriminatedUnion works when nested inside a co.list", () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const Pets = co.list(Pet);
+
+    const Person = co.map({
+      pets: Pets,
+    });
+
+    const pets = Pets.create([
+      Dog.create({
+        type: "dog",
+      }),
+      Cat.create({
+        type: "cat",
+      }),
+    ]);
+    const person = Person.create({
+      pets,
+    });
+
+    expect(person.pets[0]?.type).toEqual("dog");
+    expect(person.pets[1]?.type).toEqual("cat");
+  });
+
+  test("co.discriminatedUnion works when used in a recursive reference", () => {
+    const NoteItem = co.map({
+      type: z.literal("note"),
+      internal: z.boolean(),
+      content: co.plainText(),
+    });
+
+    const AttachmentItem = co.map({
+      type: z.literal("attachment"),
+      internal: z.boolean(),
+      content: co.fileStream(),
+    });
+
+    const ReferenceItem = co.map({
+      type: z.literal("reference"),
+      internal: z.boolean(),
+      content: z.string(),
+
+      get child(): co.DiscriminatedUnion<
+        [typeof NoteItem, typeof AttachmentItem, typeof ReferenceItem]
+      > {
+        return ProjectContextItem;
+      },
+    });
+
+    const ProjectContextItem = co.discriminatedUnion("type", [
+      NoteItem,
+      AttachmentItem,
+      ReferenceItem,
+    ]);
+
+    const referenceItem = ReferenceItem.create({
+      type: "reference",
+      internal: false,
+      content: "Hello",
+      child: NoteItem.create({
+        type: "note",
+        internal: false,
+        content: CoPlainText.create("Hello"),
+      }),
+    });
+
+    expect(referenceItem.child.type).toEqual("note");
+  });
+
+  test("co.discriminatedUnion works when used inside another schema in a recursive reference", () => {
+    const NoteItem = co.map({
+      type: z.literal("note"),
+      internal: z.boolean(),
+      content: co.plainText(),
+    });
+
+    const AttachmentItem = co.map({
+      type: z.literal("attachment"),
+      internal: z.boolean(),
+      content: co.fileStream(),
+    });
+
+    const ReferenceItem = co.map({
+      type: z.literal("reference"),
+      internal: z.boolean(),
+      content: z.string(),
+
+      get children(): co.List<
+        co.DiscriminatedUnion<
+          [typeof NoteItem, typeof AttachmentItem, typeof ReferenceItem]
+        >
+      > {
+        return ProjectContextItems;
+      },
+    });
+
+    const ProjectContextItem = co.discriminatedUnion("type", [
+      NoteItem,
+      AttachmentItem,
+      ReferenceItem,
+    ]);
+
+    const ProjectContextItems = co.list(ProjectContextItem);
+
+    const referenceItem = ReferenceItem.create({
+      type: "reference",
+      internal: false,
+      content: "Hello",
+      children: ProjectContextItems.create([
+        NoteItem.create({
+          type: "note",
+          internal: false,
+          content: CoPlainText.create("Hello"),
+        }),
+      ]),
+    });
+
+    expect(referenceItem.children[0]?.type).toEqual("note");
+  });
+
   test("load CoValue instances using the DiscriminatedUnion schema", async () => {
     const Dog = co.map({
       type: z.literal("dog"),

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

@@ -70,9 +70,10 @@ describe("CoFeed", () => {
     });
 
     test("CoFeed create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -80,11 +81,11 @@ describe("CoFeed", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const feed = DogFeed.create([dog, undefined]);
 

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

@@ -74,9 +74,10 @@ describe("CoList", () => {
     });
 
     test("CoList create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -84,11 +85,11 @@ describe("CoList", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const list = DogList.create([dog, undefined]);
 
@@ -101,6 +102,34 @@ describe("CoList", () => {
       matches(list);
     });
 
+    test("CoList with recursive reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+        get friends() {
+          return DogList.optional();
+        },
+      });
+
+      const DogList = co.list(Dog);
+
+      const rex = Dog.create({
+        name: "Rex",
+        breed: "Labrador",
+        friends: DogList.create([]),
+      });
+
+      const list = DogList.create([rex]);
+
+      type ExpectedType = Loaded<typeof Dog>[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
     test("CoList with nested lists", () => {
       const NestedList = co.list(co.list(z.string()));
 

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

@@ -1,7 +1,11 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { Account, Group, subscribeToCoValue, z } from "../index.js";
-import { Loaded, anySchemaToCoSchema, co } from "../internal.js";
+import {
+  Loaded,
+  co,
+  coValueClassFromCoValueClassOrSchema,
+} from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -580,7 +584,7 @@ describe("CoList subscription", async () => {
     const spy = vi.fn((list) => updates.push(list));
 
     subscribeToCoValue(
-      anySchemaToCoSchema(TestList),
+      coValueClassFromCoValueClassOrSchema(TestList),
       list.id,
       {
         syncResolution: true,
@@ -806,3 +810,17 @@ describe("CoList subscription", async () => {
     expect(spy).toHaveBeenCalledTimes(2);
   });
 });
+
+describe("co.list schema", () => {
+  test("can access the inner schema of a co.list", () => {
+    const Keywords = co.list(co.plainText());
+
+    const keywords = Keywords.create([
+      Keywords.element.create("hello"),
+      Keywords.element.create("world"),
+    ]);
+
+    expect(keywords[0]?.toString()).toEqual("hello");
+    expect(keywords[1]?.toString()).toEqual("world");
+  });
+});

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

@@ -81,9 +81,10 @@ describe("CoMap.Record", () => {
     });
 
     test("Record create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -91,11 +92,11 @@ describe("CoMap.Record", () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
-      }) as Dog;
+      });
 
       const record = DogRecord.create({
         pet1: dog,
@@ -112,6 +113,33 @@ describe("CoMap.Record", () => {
 
       matches(record);
     });
+
+    test("Record with recursive reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        get owner() {
+          return Person.optional();
+        },
+      });
+
+      const Person = co.record(z.string(), Dog);
+
+      const person = Person.create({
+        pet1: Dog.create({ name: "Rex" }),
+      });
+
+      person.pet1!.owner = person;
+
+      type ExpectedType = {
+        [key: string]: Loaded<typeof Dog> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
   });
 
   describe("Record resolution", () => {

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

@@ -236,9 +236,6 @@ describe("CoMap.Record", async () => {
         pet1: Dog.create({ name: "Rex", breed: "Labrador" }),
       });
 
-      type V = (typeof Person)["_zod"]["def"]["valueType"];
-      type T = InstanceOrPrimitiveOfSchema<typeof Person>;
-
       const updates: Loaded<typeof Person, { $each: true }>[] = [];
       const spy = vi.fn((person) => updates.push(person));
 
@@ -301,7 +298,7 @@ describe("CoMap.Record", async () => {
   });
 
   // Covers https://github.com/garden-co/jazz/issues/2385
-  test("create a Record with a discriminated union containing a co.map that uses withHelpers", () => {
+  test("create a Record with a discriminated union containing a co.image", () => {
     const Base = co.map({
       type: z.literal("base"),
       name: z.string(),
@@ -309,8 +306,8 @@ describe("CoMap.Record", async () => {
 
     const IssueRepro = co.map({
       type: z.literal("repro"),
-      catchall: co.map({}).withHelpers((self) => self),
       name: z.string(),
+      image: co.image(),
     });
 
     const PersonRecord = co.record(
@@ -320,8 +317,10 @@ describe("CoMap.Record", async () => {
 
     const person = IssueRepro.create({
       type: "repro",
-      catchall: IssueRepro.def.shape.catchall.create({}),
       name: "John",
+      image: co.image().create({
+        originalSize: [1920, 1080],
+      }),
     });
 
     const record = PersonRecord.create({
@@ -329,7 +328,7 @@ describe("CoMap.Record", async () => {
     });
 
     if (record.john?.type === "repro") {
-      expect(record.john.catchall).toEqual({});
+      expect(record.john.image.originalSize).toEqual([1920, 1080]);
       expect(record.john.name).toEqual("John");
       expect(record.john.type).toEqual("repro");
     }
@@ -342,9 +341,10 @@ describe("CoMap.Record", async () => {
       name: z.string(),
     });
 
+    const Catchall = co.map({}).catchall(z.string());
     const IssueRepro = co.map({
       type: z.literal("repro"),
-      catchall: co.map({}).catchall(z.string()),
+      catchall: Catchall,
       name: z.string(),
     });
 
@@ -355,7 +355,7 @@ describe("CoMap.Record", async () => {
 
     const person = IssueRepro.create({
       type: "repro",
-      catchall: IssueRepro.def.shape.catchall.create({}),
+      catchall: Catchall.create({}),
       name: "John",
     });
 

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

@@ -1,7 +1,7 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
-import { CoListSchema, Loaded } from "../internal.js";
+import { Loaded } from "../internal.js";
 
 describe("CoMap", async () => {
   describe("init", () => {
@@ -117,9 +117,10 @@ describe("CoMap", async () => {
     });
 
     test("CoMap create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -131,7 +132,7 @@ describe("CoMap", async () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
@@ -158,8 +159,8 @@ describe("CoMap", async () => {
 
     test("Comap with recursive optional reference", () => {
       const Recursive = co.map({
-        get child(): z.ZodOptional<typeof Recursive> {
-          return co.optional(Recursive);
+        get child() {
+          return Recursive.optional();
         },
       });
 
@@ -183,8 +184,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        // TODO: would be nice if this didn't need a type annotation
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend() {
           return co.optional(Person);
         },
       });
@@ -243,7 +243,7 @@ describe("CoMap", async () => {
     test("update a reference on a loaded value", () => {
       const Dog = co.map({
         name: z.string(),
-        get siblings(): CoListSchema<typeof Dog> {
+        get siblings() {
           return co.list(Dog);
         },
       });