jazz-tools 0.20.0 → 0.20.2

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

@@ -1225,3 +1225,265 @@ describe("lastUpdatedAt", () => {
     expect(list.$jazz.lastUpdatedAt).not.toEqual(updatedAt);
   });
 });
+
+describe("CoList proxy traps", () => {
+  test(".values() returns the same values as Object.values()", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+    list.$jazz.push("bread");
+    list.$jazz.push("butter");
+    list.$jazz.push("onion");
+
+    const valuesFromMethod = [...list.values()];
+    const valuesFromObject = Object.values(list);
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+    expect(valuesFromMethod).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test(".values().map() returns the same values as .map()", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+    list.$jazz.push("bread");
+    list.$jazz.push("butter");
+    list.$jazz.push("onion");
+
+    const valuesFromMethod = [...list.values().map((v) => v.toUpperCase())];
+    const valuesFromObject = list.map((v) => v.toUpperCase());
+
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+    expect(valuesFromMethod).toEqual(["BREAD", "BUTTER", "ONION"]);
+  });
+
+  test(".keys() returns numeric indices", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const keys = [...list.keys()];
+
+    expect(keys).toEqual([0, 1, 2]);
+  });
+
+  test(".entries() returns index-value pairs", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const entries = [...list.entries()];
+
+    expect(entries).toEqual([
+      [0, "bread"],
+      [1, "butter"],
+      [2, "onion"],
+    ]);
+  });
+
+  test("for...of iteration works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items: string[] = [];
+    for (const item of list) {
+      items.push(item);
+    }
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test("spread operator works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items = [...list];
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test("Array.from works correctly", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["bread", "butter", "onion"]);
+
+    const items = Array.from(list);
+
+    expect(items).toEqual(["bread", "butter", "onion"]);
+  });
+
+  test(".values() works with CoValue references", () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+    const DogList = co.list(Dog);
+
+    const list = DogList.create([
+      { name: "Rex" },
+      { name: "Fido" },
+      { name: "Buddy" },
+    ]);
+
+    const valuesFromMethod = [...list.values()];
+    const valuesFromObject = Object.values(list);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((d) => d?.name)).toEqual([
+      "Rex",
+      "Fido",
+      "Buddy",
+    ]);
+    expect(valuesFromMethod).toEqual(valuesFromObject);
+  });
+
+  test(".values() works after ensureLoaded", async () => {
+    const Task = co.map({
+      title: z.string(),
+    });
+    const TaskList = co.list(Task);
+
+    const list = TaskList.create([
+      { title: "Task 1" },
+      { title: "Task 2" },
+      { title: "Task 3" },
+    ]);
+
+    const loadedList = await list.$jazz.ensureLoaded({
+      resolve: { $each: true },
+    });
+
+    const valuesFromMethod = [...loadedList.values()];
+    const valuesFromObject = Object.values(loadedList);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((t) => t.title)).toEqual([
+      "Task 1",
+      "Task 2",
+      "Task 3",
+    ]);
+    expect(valuesFromMethod.map((t) => t.$jazz.id)).toEqual(
+      valuesFromObject.map((t) => t.$jazz.id),
+    );
+  });
+
+  test(".values() works on remotely loaded list", async () => {
+    const Task = co.map({
+      title: z.string(),
+    });
+    const TaskList = co.list(Task);
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
+
+    const list = TaskList.create(
+      [{ title: "Task 1" }, { title: "Task 2" }, { title: "Task 3" }],
+      group,
+    );
+
+    const userB = await createJazzTestAccount();
+
+    const loadedList = await TaskList.load(list.$jazz.id, {
+      resolve: { $each: true },
+      loadAs: userB,
+    });
+
+    assertLoaded(loadedList);
+
+    const valuesFromMethod = [...loadedList.values()];
+    const valuesFromObject = Object.values(loadedList);
+
+    expect(valuesFromMethod.length).toBe(3);
+    expect(valuesFromMethod.map((t) => t.title)).toEqual([
+      "Task 1",
+      "Task 2",
+      "Task 3",
+    ]);
+    expect(valuesFromMethod.map((t) => t.$jazz.id)).toEqual(
+      valuesFromObject.map((t) => t.$jazz.id),
+    );
+  });
+
+  test("iterator methods work on empty list", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create([]);
+
+    expect([...list.values()]).toEqual([]);
+    expect([...list.keys()]).toEqual([]);
+    expect([...list.entries()]).toEqual([]);
+    expect([...list]).toEqual([]);
+  });
+
+  test("Object.getOwnPropertyDescriptors returns correct descriptors", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["a", "b", "c"]);
+
+    const descriptors = Object.getOwnPropertyDescriptors(list);
+
+    // Check numeric index descriptors
+    expect(descriptors["0"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "a",
+    });
+    expect(descriptors["1"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "b",
+    });
+    expect(descriptors["2"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: "c",
+    });
+
+    // Check length descriptor
+    expect(descriptors["length"]).toEqual({
+      enumerable: false,
+      configurable: false,
+      writable: true,
+      value: 3,
+    });
+
+    // Verify only expected enumerable keys
+    const enumerableKeys = Object.keys(descriptors).filter(
+      (key) => descriptors[key]?.enumerable,
+    );
+    expect(enumerableKeys.sort()).toEqual(["0", "1", "2"]);
+  });
+
+  test("Object.getOwnPropertyDescriptors returns the resolved references", () => {
+    const TestList = co.list(co.map({ name: z.string() }));
+    const list = TestList.create([{ name: "a" }, { name: "b" }, { name: "c" }]);
+
+    const descriptors = Object.getOwnPropertyDescriptors(list);
+
+    // Check numeric index descriptors
+    expect(descriptors["0"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[0],
+    });
+    expect(descriptors["1"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[1],
+    });
+    expect(descriptors["2"]).toEqual({
+      enumerable: true,
+      configurable: true,
+      writable: false,
+      value: list[2],
+    });
+  });
+
+  test("setting the lenght to 0 has no effect", () => {
+    const TestList = co.list(z.string());
+    const list = TestList.create(["a", "b", "c"]);
+
+    list.length = 0;
+
+    expect(list.length).toBe(3);
+    expect(list[0]).toBe("a");
+    expect(list[1]).toBe("b");
+    expect(list[2]).toBe("c");
+  });
+});

package/src/tools/tests/schema.withPermissions.test.ts

@@ -843,7 +843,7 @@ describe("setDefaultSchemaPermissions", () => {
     expect(childOwner.getRoleOf(anotherAccount.$jazz.id)).toEqual("reader");
   });
 
-  test("does not modify permissions for existing schemas", () => {
+  test("modifies default permissions for existing schemas", () => {
     const ExistingMap = co.map({
       name: co.plainText(),
     });
@@ -852,8 +852,31 @@ describe("setDefaultSchemaPermissions", () => {
     });
 
     const map = ExistingMap.create({ name: "Hello" });
-    expect(
-      map.name.$jazz.owner.getParentGroups().map((group) => group.$jazz.id),
-    ).toContain(map.$jazz.owner.$jazz.id);
+    expect(map.name.$jazz.owner.$jazz.id).toContain(map.$jazz.owner.$jazz.id);
+  });
+
+  test("modifies default permissions for copied schemas", async () => {
+    const anotherAccount = await createJazzTestAccount();
+
+    const ExistingMap = co.map({
+      name: co.plainText(),
+    });
+    setDefaultSchemaPermissions({
+      onCreate() {
+        // Do nothing
+      },
+    });
+    const CopiedMap = ExistingMap.resolved({ name: true });
+    setDefaultSchemaPermissions({
+      onCreate(newGroup) {
+        newGroup.addMember(anotherAccount, "reader");
+      },
+    });
+
+    const map = CopiedMap.create({ name: "Hello" });
+    await map.$jazz.waitForSync();
+
+    const mapOwner = map.$jazz.owner;
+    expect(mapOwner.getRoleOf(anotherAccount.$jazz.id)).toEqual("reader");
   });
 });