jazz-tools 0.7.0-alpha.3 → 0.7.0-alpha.31

package/src/tests/coList.test.ts

@@ -4,7 +4,7 @@ import { webcrypto } from "node:crypto";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Account, CoList, jazzReady } from "..";
+import { Account, CoList, co, jazzReady } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -17,13 +17,12 @@ beforeEach(async () => {
 
 describe("Simple CoList operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
-    class TestList extends CoList<string> {}
-    TestList.encoding({ _item: "json" });
+    class TestList extends CoList.Of(co.string) {}
 
-    const list = new TestList(["bread", "butter", "onion"], { owner: me });
+    const list = TestList.create(["bread", "butter", "onion"], { owner: me });
 
     test("Construction", () => {
         expect(list[0]).toBe("bread");
@@ -40,7 +39,7 @@ describe("Simple CoList operations", async () => {
 
     describe("Mutation", () => {
         test("assignment", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list[1] = "margarine";
@@ -53,7 +52,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("push", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.push("cheese");
@@ -67,7 +66,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("unshift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.unshift("lettuce");
@@ -81,7 +80,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("pop", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.pop()).toBe("onion");
@@ -90,7 +89,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("shift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.shift()).toBe("bread");
@@ -98,49 +97,46 @@ describe("Simple CoList operations", async () => {
             expect(list._raw.asArray()).toEqual(["butter", "onion"]);
         });
 
-        // test("splice", () => {
-        //     const list = new TestList(["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("splice", () => {
+            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",
+            ]);
+        });
     });
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends CoList<string> {
+    class TwiceNestedList extends CoList.Of(co.string) {
         joined() {
             return this.join(",");
         }
     }
-    TwiceNestedList.encoding({ _item: "json" });
 
-    class NestedList extends CoList<TwiceNestedList | null> {}
-    NestedList.encoding({ _item: { ref: () => TwiceNestedList } });
+    class NestedList extends CoList.Of(co.ref(TwiceNestedList)) {}
 
-    class TestList extends CoList<NestedList | null> {}
-    TestList.encoding({ _item: { ref: () => NestedList } });
+    class TestList extends CoList.Of(co.ref(NestedList)) {}
 
     const initNodeAndList = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
-        const list = new TestList(
+        const list = TestList.create(
             [
-                new NestedList(
-                    [new TwiceNestedList(["a", "b"], { owner: me })],
+                NestedList.create(
+                    [TwiceNestedList.create(["a", "b"], { owner: me })],
                     { owner: me }
                 ),
-                new NestedList(
-                    [new TwiceNestedList(["c", "d"], { owner: me })],
+                NestedList.create(
+                    [TwiceNestedList.create(["c", "d"], { owner: me })],
                     { owner: me }
                 ),
             ],
@@ -200,8 +196,8 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
         expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
-        const otherNestedList = new NestedList(
-            [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
+        const otherNestedList = NestedList.create(
+            [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
             { owner: meOnSecondPeer }
         );
 
@@ -261,11 +257,11 @@ describe("CoList resolution", async () => {
 
                 // When assigning a new nested value, we get an update
 
-                const newTwiceNestedList = new TwiceNestedList(["y", "z"], {
+                const newTwiceNestedList = TwiceNestedList.create(["y", "z"], {
                     owner: meOnSecondPeer,
                 });
 
-                const newNestedList = new NestedList([newTwiceNestedList], {
+                const newNestedList = NestedList.create([newTwiceNestedList], {
                     owner: meOnSecondPeer,
                 });
 

package/src/tests/coMap.test.ts

@@ -4,7 +4,7 @@ import { webcrypto } from "node:crypto";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Account, jazzReady, Encoders, indexSignature, CoMap } from "..";
+import { Account, jazzReady, Encoders, CoMap, co } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -17,34 +17,28 @@ beforeEach(async () => {
 
 describe("Simple CoMap operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
-    class TestMap extends CoMap<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare birthday: Date;
-        declare name?: string;
+    class TestMap extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
 
-        get _roughColor() {
+        get roughColor() {
             return this.color + "ish";
         }
     }
-    TestMap.encoding({
-        color: "json",
-        height: "json",
-        birthday: { encoded: Encoders.Date },
-        name: "json",
-    });
 
-    console.log("TestMap schema", TestMap.prototype._encoding);
+    console.log("TestMap schema", TestMap.prototype._schema);
 
     const birthday = new Date();
 
-    const map = new TestMap(
+    const map = TestMap.create(
         {
             color: "red",
-            height: 10,
+            _height: 10,
             birthday: birthday,
         },
         { owner: me }
@@ -52,14 +46,15 @@ describe("Simple CoMap operations", async () => {
 
     test("Construction", () => {
         expect(map.color).toEqual("red");
-        expect(map._roughColor).toEqual("redish");
-        expect(map.height).toEqual(10);
+        expect(map.roughColor).toEqual("redish");
+        expect(map._height).toEqual(10);
         expect(map.birthday).toEqual(birthday);
         expect(map._raw.get("birthday")).toEqual(birthday.toISOString());
+        expect(Object.keys(map)).toEqual(["color", "_height", "birthday"]);
     });
 
     describe("Mutation", () => {
-        test("assignment", () => {
+        test("assignment & deletion", () => {
             map.color = "blue";
             expect(map.color).toEqual("blue");
             expect(map._raw.get("color")).toEqual("blue");
@@ -68,35 +63,35 @@ describe("Simple CoMap operations", async () => {
             expect(map.birthday).toEqual(newBirthday);
             expect(map._raw.get("birthday")).toEqual(newBirthday.toISOString());
 
-            Object.assign(map, { color: "green", height: 20 });
+            Object.assign(map, { color: "green", _height: 20 });
             expect(map.color).toEqual("green");
             expect(map._raw.get("color")).toEqual("green");
-            expect(map.height).toEqual(20);
-            expect(map._raw.get("height")).toEqual(20);
+            expect(map._height).toEqual(20);
+            expect(map._raw.get("_height")).toEqual(20);
 
             map.name = "Secret name";
             expect(map.name).toEqual("Secret name");
             map.name = undefined;
             expect(map.name).toEqual(undefined);
+            expect(Object.keys(map)).toContain("name");
+            delete map.name;
+            expect(map.name).toEqual(undefined);
+            expect(Object.keys(map)).not.toContain("name");
         });
     });
 
-    class RecursiveMap extends CoMap<RecursiveMap> {
-        declare name: string;
-        declare next: RecursiveMap | null;
+    class RecursiveMap extends CoMap {
+        name = co.string;
+        next: co<RecursiveMap | null> = co.ref(RecursiveMap);
     }
-    RecursiveMap.encoding({
-        name: "json",
-        next: { ref: () => RecursiveMap },
-    });
 
-    const recursiveMap = new RecursiveMap(
+    const recursiveMap = RecursiveMap.create(
         {
             name: "first",
-            next: new RecursiveMap(
+            next: RecursiveMap.create(
                 {
                     name: "second",
-                    next: new RecursiveMap(
+                    next: RecursiveMap.create(
                         {
                             name: "third",
                         },
@@ -116,57 +111,104 @@ describe("Simple CoMap operations", async () => {
             expect(recursiveMap.next?.next?.name).toEqual("third");
         });
     });
+
+    class MapWithEnumOfMaps extends CoMap {
+        name = co.string;
+        child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
+            raw.get("type") === "a" ? ChildA : ChildB
+        );
+    }
+
+    class ChildA extends CoMap {
+        type = co.literal("a");
+        value = co.number;
+    }
+
+    class ChildB extends CoMap {
+        type = co.literal("b");
+        value = co.string;
+    }
+
+    const mapWithEnum = MapWithEnumOfMaps.create(
+        {
+            name: "enum",
+            child: ChildA.create(
+                {
+                    type: "a",
+                    value: 5,
+                },
+                { owner: me }
+            ),
+        },
+        { owner: me }
+    );
+
+    test("Enum of maps", () => {
+        expect(mapWithEnum.name).toEqual("enum");
+        expect(mapWithEnum.child?.type).toEqual("a");
+        expect(mapWithEnum.child?.value).toEqual(5);
+        expect(mapWithEnum.child?.id).toBeDefined();
+    });
+
+    class SuperClassMap extends CoMap {
+        name = co.string;
+    }
+
+    class SubClassMap extends SuperClassMap {
+        name = co.literal("specificString");
+        value = co.number;
+        extra = co.ref(TestMap);
+    }
+    interface SubClassMap extends CoMap {}
+
+    class GenericMapWithLoose<
+        out T extends string = string,
+    > extends CoMap {
+        name = co.json<T>();
+    }
+
+    const loose: GenericMapWithLoose<string> = {} as GenericMapWithLoose<
+        "a" | "b"
+    >;
 });
 
 describe("CoMap resolution", async () => {
-    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
-        taste!: string;
+    class TwiceNestedMap extends CoMap {
+        taste = co.string;
     }
-    TwiceNestedMap.encoding({
-        taste: "json",
-    });
 
-    class NestedMap extends CoMap<NestedMap> {
-        name!: string;
-        twiceNested!: TwiceNestedMap | null;
+    class NestedMap extends CoMap {
+        name = co.string;
+        twiceNested = co.ref(TwiceNestedMap);
 
         get _fancyName() {
             return "Sir " + this.name;
         }
     }
-    NestedMap.encoding({
-        name: "json",
-        twiceNested: { ref: () => TwiceNestedMap },
-    });
 
-    class TestMap extends CoMap<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare nested: NestedMap | null;
+    class TestMap extends CoMap {
+        color = co.string;
+        height = co.number;
+        nested = co.ref(NestedMap);
 
         get _roughColor() {
             return this.color + "ish";
         }
     }
-    TestMap.encoding({
-        color: "json",
-        height: "json",
-        nested: { ref: () => NestedMap },
-    });
 
     const initNodeAndMap = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
-        const map = new TestMap(
+        const map = TestMap.create(
             {
                 color: "red",
                 height: 10,
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "nested",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
                             { owner: me }
                         ),
@@ -236,10 +278,10 @@ describe("CoMap resolution", async () => {
             loadedTwiceNestedMap
         );
 
-        const otherNestedMap = new NestedMap(
+        const otherNestedMap = NestedMap.create(
             {
                 name: "otherNested",
-                twiceNested: new TwiceNestedMap(
+                twiceNested: TwiceNestedMap.create(
                     { taste: "sweet" },
                     { owner: meOnSecondPeer }
                 ),
@@ -305,14 +347,14 @@ describe("CoMap resolution", async () => {
                 expect(oldTwiceNested?.taste).toEqual("sour");
 
                 // When assigning a new nested value, we get an update
-                const newTwiceNested = new TwiceNestedMap(
+                const newTwiceNested = TwiceNestedMap.create(
                     {
                         taste: "sweet",
                     },
                     { owner: meOnSecondPeer }
                 );
 
-                const newNested = new NestedMap(
+                const newNested = NestedMap.create(
                     {
                         name: "newNested",
                         twiceNested: newTwiceNested,
@@ -341,21 +383,17 @@ describe("CoMap resolution", async () => {
         );
     });
 
-    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
-        declare color: string;
-        declare nested?: NestedMap | null;
+    class TestMapWithOptionalRef extends CoMap {
+        color = co.string;
+        nested? = co.ref(NestedMap);
     }
-    TestMapWithOptionalRef.encoding({
-        color: "json",
-        nested: { ref: () => NestedMap },
-    });
 
     test("Construction with optional", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
-        const mapWithout = new TestMapWithOptionalRef(
+        const mapWithout = TestMapWithOptionalRef.create(
             {
                 color: "red",
             },
@@ -365,13 +403,13 @@ describe("CoMap resolution", async () => {
         expect(mapWithout.color).toEqual("red");
         expect(mapWithout.nested).toEqual(undefined);
 
-        const mapWith = new TestMapWithOptionalRef(
+        const mapWith = TestMapWithOptionalRef.create(
             {
                 color: "red",
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "wow!",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
                             { owner: me }
                         ),
@@ -388,20 +426,17 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends CoMap<TestRecord> {
-        declare [indexSignature]: number;
+    class TestRecord extends CoMap {
+        [co.items] = co.number;
     }
     interface TestRecord extends Record<string, number> {}
-    TestRecord.encoding({
-        [indexSignature]: "json",
-    });
 
     test("Construction with index signature", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
-        const record = new TestRecord(
+        const record = TestRecord.create(
             {
                 height: 5,
                 other: 3,
@@ -414,5 +449,65 @@ describe("CoMap resolution", async () => {
         expect(record.other).toEqual(3);
         expect(record._raw.get("other")).toEqual(3);
         expect(Object.keys(record)).toEqual(["height", "other"]);
+        expect(record.toJSON()).toMatchObject({
+            _type: "CoMap",
+            height: 5,
+            id: expect.any(String),
+            other: 3,
+        });
+    });
+
+    class TestRecord2 extends CoMap.Record(co.number) {}
+
+    test("Construction with index signature (shorthand)", async () => {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+        });
+
+        const record = TestRecord2.create(
+            {
+                height: 5,
+                other: 3,
+            },
+            { owner: me }
+        );
+
+        expect(record.height).toEqual(5);
+        expect(record._raw.get("height")).toEqual(5);
+        expect(record.other).toEqual(3);
+        expect(record._raw.get("other")).toEqual(3);
+        expect(Object.keys(record)).toEqual(["height", "other"]);
+    });
+
+    class TestRecordRef extends CoMap.Record(co.ref(TwiceNestedMap)) {}
+
+    test("Construction with index signature ref", async () => {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+        });
+
+        const record = TestRecordRef.create(
+            {
+                firstNested: TwiceNestedMap.create(
+                    { taste: "sour" },
+                    { owner: me }
+                ),
+                secondNested: TwiceNestedMap.create(
+                    { taste: "sweet" },
+                    { owner: me }
+                ),
+            },
+            { owner: me }
+        );
+
+        expect(record.firstNested?.taste).toEqual("sour");
+        expect(record.firstNested?.id).toBeDefined();
+        expect(record.secondNested?.taste).toEqual("sweet");
+        expect(record.secondNested?.id).toBeDefined();
+        expect(Object.keys(record)).toEqual(["firstNested", "secondNested"]);
+        expect(Object.keys(record._refs)).toEqual([
+            "firstNested",
+            "secondNested",
+        ]);
     });
 });