jazz-tools 0.11.3 → 0.11.4

package/src/tests/coList.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, test } from "vitest";
 import {
   Account,
   CoList,
+  CoMap,
   Group,
   co,
   createJazzContextFromExistingCredentials,
@@ -61,6 +62,69 @@ describe("Simple CoList operations", async () => {
       expect(list[1]).toBe("margarine");
     });
 
+    test("assignment with ref", () => {
+      class Ingredient extends CoMap {
+        name = co.string;
+      }
+
+      class Recipe extends CoList.Of(co.ref(Ingredient)) {}
+
+      const recipe = Recipe.create(
+        [
+          Ingredient.create({ name: "bread" }, me),
+          Ingredient.create({ name: "butter" }, me),
+          Ingredient.create({ name: "onion" }, me),
+        ],
+        { owner: me },
+      );
+
+      recipe[1] = Ingredient.create({ name: "margarine" }, me);
+      expect(recipe[1]?.name).toBe("margarine");
+    });
+
+    test("assign null on a required ref", () => {
+      class Ingredient extends CoMap {
+        name = co.string;
+      }
+
+      class Recipe extends CoList.Of(co.ref(Ingredient)) {}
+
+      const recipe = Recipe.create(
+        [
+          Ingredient.create({ name: "bread" }, me),
+          Ingredient.create({ name: "butter" }, me),
+          Ingredient.create({ name: "onion" }, me),
+        ],
+        { owner: me },
+      );
+
+      expect(() => {
+        recipe[1] = null;
+      }).toThrow("Cannot set required reference 1 to null");
+
+      expect(recipe[1]?.name).toBe("butter");
+    });
+
+    test("assign null on an optional ref", () => {
+      class Ingredient extends CoMap {
+        name = co.string;
+      }
+
+      class Recipe extends CoList.Of(co.optional.ref(Ingredient)) {}
+
+      const recipe = Recipe.create(
+        [
+          Ingredient.create({ name: "bread" }, me),
+          Ingredient.create({ name: "butter" }, me),
+          Ingredient.create({ name: "onion" }, me),
+        ],
+        { owner: me },
+      );
+
+      recipe[1] = null;
+      expect(recipe[1]).toBe(null);
+    });
+
     test("push", () => {
       const list = TestList.create(["bread", "butter", "onion"], {
         owner: me,
@@ -107,13 +171,115 @@ describe("Simple CoList operations", async () => {
       expect(list._raw.asArray()).toEqual(["butter", "onion"]);
     });
 
-    test("splice", () => {
-      const list = TestList.create(["bread", "butter", "onion"], {
-        owner: me,
+    describe("splice", () => {
+      test("insert after 1st item with 1 item removed", () => {
+        const list = TestList.create(["bread", "butter", "onion"], {
+          owner: me,
+        });
+        list.splice(1, 1, "salt", "pepper");
+        expect(list.length).toBe(4);
+        expect(list._raw.asArray()).toEqual([
+          "bread",
+          "salt",
+          "pepper",
+          "onion",
+        ]);
+      });
+
+      test("insert before 1st item", () => {
+        const list = TestList.create(["bread", "butter", "onion"], {
+          owner: me,
+        });
+        list.splice(0, 0, "salt", "pepper");
+        expect(list.length).toBe(5);
+        expect(list._raw.asArray()).toEqual([
+          "salt",
+          "pepper",
+          "bread",
+          "butter",
+          "onion",
+        ]);
+      });
+
+      test("insert after 1st item", () => {
+        const list = TestList.create(["bread", "butter", "onion"], {
+          owner: me,
+        });
+        list.splice(1, 0, "salt", "pepper");
+        expect(list.length).toBe(5);
+        expect(list._raw.asArray()).toEqual([
+          "bread",
+          "salt",
+          "pepper",
+          "butter",
+          "onion",
+        ]);
+      });
+
+      test("insert after 2nd item", () => {
+        const list = TestList.create(["bread", "butter", "onion"], {
+          owner: me,
+        });
+        list.splice(2, 0, "salt", "pepper");
+        expect(list.length).toBe(5);
+        expect(list._raw.asArray()).toEqual([
+          "bread",
+          "butter",
+          "salt",
+          "pepper",
+          "onion",
+        ]);
       });
-      list.splice(1, 1, "salt", "pepper");
-      expect(list.length).toBe(4);
-      expect(list._raw.asArray()).toEqual(["bread", "salt", "pepper", "onion"]);
+    });
+
+    test("sort", () => {
+      const list = TestList.create(
+        ["hedgehog", "giraffe", "iguana", "flamingo"],
+        { owner: me },
+      );
+
+      list.sort();
+      expect(list._raw.asArray()).toEqual([
+        "flamingo",
+        "giraffe",
+        "hedgehog",
+        "iguana",
+      ]);
+
+      list.sort((a, b) => b.localeCompare(a));
+      expect(list._raw.asArray()).toEqual([
+        "iguana",
+        "hedgehog",
+        "giraffe",
+        "flamingo",
+      ]);
+    });
+
+    test("sort list of refs", async () => {
+      class Message extends CoMap {
+        text = co.string;
+      }
+
+      class Chat extends CoList.Of(co.ref(Message)) {}
+
+      const chat = Chat.create(
+        [
+          Message.create({ text: "world" }, { owner: me }),
+          Message.create({ text: "hello" }, { owner: me }),
+        ],
+        { owner: me },
+      );
+
+      chat.sort((a, b) => a!.text.localeCompare(b!.text));
+      expect(chat.map((m) => m!.text)).toEqual(["hello", "world"]);
+
+      chat.push(Message.create({ text: "beans on toast" }, { owner: me }));
+      chat.sort((a, b) => a!.text.localeCompare(b!.text));
+      expect(chat.map((m) => m!.text)).toEqual([
+        "beans on toast",
+        "hello",
+        "world",
+      ]);
     });
 
     test("applyDiff", () => {
@@ -135,6 +301,147 @@ describe("Simple CoList operations", async () => {
         "cheese",
       ]);
     });
+
+    test("filter + assign to coMap", () => {
+      class TestMap extends CoMap {
+        list = co.ref(TestList);
+      }
+
+      const map = TestMap.create(
+        {
+          list: TestList.create(["bread", "butter", "onion"], {
+            owner: me,
+          }),
+        },
+        { owner: me },
+      );
+
+      expect(() => {
+        // @ts-expect-error
+        map.list = map.list?.filter((item) => item !== "butter");
+      }).toThrow("Cannot set reference list to a non-CoValue. Got bread,onion");
+
+      expect(map.list?._raw.asArray()).toEqual(["bread", "butter", "onion"]);
+    });
+
+    test("filter + assign to CoList", () => {
+      class TestListOfLists extends CoList.Of(co.ref(TestList)) {}
+
+      const list = TestListOfLists.create(
+        [
+          TestList.create(["bread", "butter", "onion"], {
+            owner: me,
+          }),
+        ],
+        { owner: me },
+      );
+
+      expect(() => {
+        // @ts-expect-error
+        list[0] = list[0]?.filter((item) => item !== "butter");
+      }).toThrow("Cannot set reference 0 to a non-CoValue. Got bread,onion");
+
+      expect(list[0]?._raw.asArray()).toEqual(["bread", "butter", "onion"]);
+    });
+  });
+});
+
+describe("CoList applyDiff operations", async () => {
+  const me = await Account.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  test("applyDiff with primitive values", () => {
+    class StringList extends CoList.Of(co.string) {}
+    const list = StringList.create(["a", "b", "c"], { owner: me });
+
+    // Test adding items
+    list.applyDiff(["a", "b", "c", "d", "e"]);
+    expect(list._raw.asArray()).toEqual(["a", "b", "c", "d", "e"]);
+
+    // Test removing items
+    list.applyDiff(["a", "c", "e"]);
+    expect(list._raw.asArray()).toEqual(["a", "c", "e"]);
+
+    // Test replacing items
+    list.applyDiff(["x", "y", "z"]);
+    expect(list._raw.asArray()).toEqual(["x", "y", "z"]);
+
+    // Test empty list
+    list.applyDiff([]);
+    expect(list._raw.asArray()).toEqual([]);
+  });
+
+  test("applyDiff with reference values", () => {
+    class NestedItem extends CoList.Of(co.string) {
+      get value() {
+        return this[0];
+      }
+    }
+    class RefList extends CoList.Of(co.ref(NestedItem)) {}
+
+    const item1 = NestedItem.create(["item1"], { owner: me });
+    const item2 = NestedItem.create(["item2"], { owner: me });
+    const item3 = NestedItem.create(["item3"], { owner: me });
+    const item4 = NestedItem.create(["item4"], { owner: me });
+
+    const list = RefList.create([item1, item2], { owner: me });
+
+    // Test adding reference items
+    list.applyDiff([item1, item2, item3]);
+    expect(list.length).toBe(3);
+    expect(list[2]?.value).toBe("item3");
+
+    // Test removing reference items
+    list.applyDiff([item1, item3]);
+    expect(list.length).toBe(2);
+    expect(list[0]?.value).toBe("item1");
+    expect(list[1]?.value).toBe("item3");
+
+    // Test replacing reference items
+    list.applyDiff([item4]);
+    expect(list.length).toBe(1);
+    expect(list[0]?.value).toBe("item4");
+
+    // Test empty list
+    list.applyDiff([]);
+    expect(list._raw.asArray()).toEqual([]);
+  });
+
+  test("applyDiff with refs + filter", () => {
+    class TestMap extends CoMap {
+      type = co.string;
+    }
+
+    class TestList extends CoList.Of(co.ref(TestMap)) {}
+
+    const bread = TestMap.create({ type: "bread" }, me);
+    const butter = TestMap.create({ type: "butter" }, me);
+    const onion = TestMap.create({ type: "onion" }, me);
+
+    const list = TestList.create([bread, butter, onion], me);
+
+    list.applyDiff(list.filter((item) => item?.type !== "butter"));
+
+    expect(list._raw.asArray()).toEqual([bread.id, onion.id]);
+  });
+
+  test("applyDiff with mixed operations", () => {
+    class StringList extends CoList.Of(co.string) {}
+    const list = StringList.create(["a", "b", "c", "d", "e"], { owner: me });
+
+    // Test multiple operations at once
+    list.applyDiff(["a", "x", "c", "y", "e"]);
+    expect(list._raw.asArray()).toEqual(["a", "x", "c", "y", "e"]);
+
+    // Test reordering
+    list.applyDiff(["e", "c", "a", "y", "x"]);
+    expect(list._raw.asArray()).toEqual(["e", "c", "a", "y", "x"]);
+
+    // Test partial update
+    list.applyDiff(["e", "c", "new", "y", "x"]);
+    expect(list._raw.asArray()).toEqual(["e", "c", "new", "y", "x"]);
   });
 });
 

package/src/tests/schemaUnion.test.ts

@@ -4,6 +4,7 @@ import { SchemaUnion } from "../coValues/schemaUnion.js";
 import {
   Account,
   CoMap,
+  CryptoProvider,
   co,
   loadCoValue,
   subscribeToCoValue,
@@ -63,7 +64,7 @@ const getWidgetSchemaFromRaw = (raw: BaseWidget["_raw"]) => {
 class WidgetUnion extends SchemaUnion.Of<BaseWidget>(getWidgetSchemaFromRaw) {}
 
 describe("SchemaUnion", () => {
-  let Crypto: WasmCrypto;
+  let Crypto: CryptoProvider;
   let me: Account;
 
   beforeAll(async () => {