jazz-tools 0.16.2 → 0.16.4

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

@@ -316,6 +316,60 @@ describe("Group inheritance", () => {
     expect(group.getRoleOf(bob.id)).toBe("reader");
     expect(group.getRoleOf(alice.id)).toBe(undefined);
   });
+
+  describe("when creating nested CoValues from a JSON object", () => {
+    const Task = co.plainText();
+    const Column = co.list(Task);
+    const Board = co.map({
+      title: z.string(),
+      columns: co.list(Column),
+    });
+
+    let board: ReturnType<typeof Board.create>;
+
+    beforeEach(async () => {
+      const me = co.account().getMe();
+      const writeAccess = Group.create();
+      writeAccess.addMember(me, "writer");
+
+      board = Board.create(
+        {
+          title: "My board",
+          columns: [
+            ["Task 1.1", "Task 1.2"],
+            ["Task 2.1", "Task 2.2"],
+          ],
+        },
+        writeAccess,
+      );
+    });
+
+    test("nested CoValues inherit permissions from the referencing CoValue", async () => {
+      const me = co.account().getMe();
+      const task = board.columns[0]![0]!;
+
+      const boardAsWriter = await Board.load(board.id, { loadAs: me });
+      expect(boardAsWriter?.title).toEqual("My board");
+      const taskAsWriter = await Task.load(task.id, { loadAs: me });
+      expect(taskAsWriter?.toString()).toEqual("Task 1.1");
+    });
+
+    test("nested CoValues inherit permissions from the referencing CoValue", async () => {
+      const me = co.account().getMe();
+      const reader = await co.account().createAs(me, {
+        creationProps: { name: "Reader" },
+      });
+
+      const task = board.columns[0]![0]!;
+      const taskGroup = task._owner.castAs(Group);
+      taskGroup.addMember(reader, "reader");
+
+      const taskAsReader = await Task.load(task.id, { loadAs: reader });
+      expect(taskAsReader?.toString()).toEqual("Task 1.1");
+      const boardAsReader = await Board.load(board.id, { loadAs: reader });
+      expect(boardAsReader).toBeNull();
+    });
+  });
 });
 
 describe("Group.getRoleOf", () => {

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

@@ -184,6 +184,25 @@ test("returns null if the value is unavailable after retries", async () => {
   expect(john).toBeNull();
 });
 
+test("load works even when the coValue access is granted after the creation", async () => {
+  const alice = await createJazzTestAccount();
+  const bob = await createJazzTestAccount();
+
+  const Person = co.map({
+    name: z.string(),
+  });
+
+  const group = Group.create(alice);
+  const map = Person.create({ name: "John" }, group);
+
+  group.addMember("everyone", "reader");
+
+  const mapOnBob = await Person.load(map.id, { loadAs: bob });
+
+  expect(mapOnBob).not.toBeNull();
+  expect(mapOnBob?.name).toBe("John");
+});
+
 test("load a large coValue", async () => {
   const syncServer = await setupJazzTestSync({ asyncPeers: true });
 

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

@@ -98,6 +98,22 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map.updatedAt).toEqual("Test");
     });
 
+    it("should handle nested optional fields", async () => {
+      const RecursiveZodSchema = z.object({
+        get optionalField() {
+          return RecursiveZodSchema.optional();
+        },
+      });
+      const CoMapSchema = co.map({ field: RecursiveZodSchema });
+
+      const map = CoMapSchema.create({
+        field: { optionalField: { optionalField: {} } },
+      });
+      expect(
+        map.field.optionalField!.optionalField!.optionalField,
+      ).toBeUndefined();
+    });
+
     it("should handle literal fields", async () => {
       const schema = co.map({
         status: z.literal("active"),