jazz-tools 0.7.0-alpha.0 → 0.7.0-alpha.11

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 { Co, S, Account, jazzReady } from "..";
+import { Account, CoList, co, jazzReady } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,7 +20,7 @@ describe("Simple CoList operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestList extends Co.list(S.string).as<TestList>() {}
+    class TestList extends CoList.Of(co.string) {}
 
     const list = new TestList(["bread", "butter", "onion"], { owner: me });
 
@@ -97,32 +97,32 @@ 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 = 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",
+        //     ]);
+        // });
     });
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends Co.list(S.string).as<TwiceNestedList>() {
+    class TwiceNestedList extends CoList.Of(co.string) {
         joined() {
             return this.join(",");
         }
     }
 
-    class NestedList extends Co.list(TwiceNestedList).as<NestedList>() {}
+    class NestedList extends CoList.Of(co.ref(TwiceNestedList)) {}
 
-    class TestList extends Co.list(NestedList).as<TestList>() {}
+    class TestList extends CoList.Of(co.ref(NestedList)) {}
 
     const initNodeAndList = async () => {
         const me = await Account.create({
@@ -173,7 +173,7 @@ describe("CoList resolution", async () => {
 
         const loadedList = await TestList.load(list.id, { as: meOnSecondPeer });
 
-        expect(loadedList?.[0]).toBe(undefined);
+        expect(loadedList?.[0]).toBe(null);
         expect(loadedList?._refs[0]?.id).toEqual(list[0]!.id);
 
         const loadedNestedList = await NestedList.load(list[0]!.id, {
@@ -181,7 +181,7 @@ describe("CoList resolution", async () => {
         });
 
         expect(loadedList?.[0]).toBeDefined();
-        expect(loadedList?.[0]?.[0]).toBeUndefined();
+        expect(loadedList?.[0]?.[0]).toBe(null);
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]![0]!.id);
         expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
 
@@ -194,9 +194,7 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?.[0]?.[0]).toBe("a");
         expect(loadedList?.[0]?.[0]?.joined()).toBe("a,b");
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
-        expect(loadedList?.[0]?._refs[0]?.value).toEqual(
-            loadedTwiceNestedList
-        );
+        expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
         const otherNestedList = new NestedList(
             [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
@@ -241,11 +239,11 @@ describe("CoList resolution", async () => {
                 );
 
                 const update1 = yield* $(Queue.take(queue));
-                expect(update1?.[0]).toEqual(undefined);
+                expect(update1?.[0]).toBe(null);
 
                 const update2 = yield* $(Queue.take(queue));
                 expect(update2?.[0]).toBeDefined();
-                expect(update2?.[0]?.[0]).toBeUndefined();
+                expect(update2?.[0]?.[0]).toBe(null);
 
                 const update3 = yield* $(Queue.take(queue));
                 expect(update3?.[0]?.[0]).toBeDefined();

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 { Co, S, Account, jazzReady } from "..";
+import { Account, jazzReady, Encoders, CoMap, co } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,23 +20,25 @@ describe("Simple CoMap operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestMap extends Co.map({
-        color: S.string,
-        height: S.number,
-        birthday: S.Date,
-        name: S.optional(S.string),
-    }).as<TestMap>() {
+    class TestMap extends CoMap<TestMap> {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
+
         get roughColor() {
             return this.color + "ish";
         }
     }
 
+    console.log("TestMap schema", TestMap.prototype._schema);
+
     const birthday = new Date();
 
     const map = new TestMap(
         {
             color: "red",
-            height: 10,
+            _height: 10,
             birthday: birthday,
         },
         { owner: me }
@@ -45,9 +47,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._height).toEqual(10);
         expect(map.birthday).toEqual(birthday);
         expect(map._raw.get("birthday")).toEqual(birthday.toISOString());
+        expect(Object.keys(map)).toEqual([
+            "color",
+            "_height",
+            "birthday",
+            "name",
+        ]);
     });
 
     describe("Mutation", () => {
@@ -58,44 +66,123 @@ describe("Simple CoMap operations", async () => {
             const newBirthday = new Date();
             map.birthday = newBirthday;
             expect(map.birthday).toEqual(newBirthday);
-            expect(map._raw.get("birthday")).toEqual(
-                newBirthday.toISOString()
-            );
+            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");
-            delete map.name;
+            map.name = undefined;
             expect(map.name).toEqual(undefined);
         });
     });
+
+    class RecursiveMap extends CoMap<RecursiveMap> {
+        name = co.string;
+        next: co<RecursiveMap | null> = co.ref(RecursiveMap);
+    }
+
+    const recursiveMap = new RecursiveMap(
+        {
+            name: "first",
+            next: new RecursiveMap(
+                {
+                    name: "second",
+                    next: new RecursiveMap(
+                        {
+                            name: "third",
+                        },
+                        { owner: me }
+                    ),
+                },
+                { owner: me }
+            ),
+        },
+        { owner: me }
+    );
+
+    describe("Recursive CoMap", () => {
+        test("Construction", () => {
+            expect(recursiveMap.name).toEqual("first");
+            expect(recursiveMap.next?.name).toEqual("second");
+            expect(recursiveMap.next?.next?.name).toEqual("third");
+        });
+    });
+
+    class MapWithEnumOfMaps extends CoMap<MapWithEnumOfMaps> {
+        name = co.string;
+        child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
+            raw.get("type") === "a" ? ChildA : ChildB
+        );
+    }
+
+    class ChildA extends CoMap<ChildA> {
+        type = co.literal("a");
+        value = co.number;
+    }
+
+    class ChildB extends CoMap<ChildB> {
+        type = co.literal("b");
+        value = co.string;
+    }
+
+    const mapWithEnum = new MapWithEnumOfMaps(
+        {
+            name: "enum",
+            child: new ChildA(
+                {
+                    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<SuperClassMap> {
+        name = co.string;
+    }
+
+    class SubClassMap extends SuperClassMap {
+        name = co.literal("specificString")
+        value = co.number;
+        extra = co.ref(TestMap)
+    }
+    interface SubClassMap extends CoMap<SubClassMap> {}
 });
 
 describe("CoMap resolution", async () => {
-    class TwiceNestedMap extends Co.map({
-        taste: S.string,
-    }).as<TwiceNestedMap>() {}
-
-    class NestedMap extends Co.map({
-        name: S.string,
-        twiceNested: TwiceNestedMap,
-    }).as<NestedMap>() {
-        get fancyName() {
+    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
+        taste = co.string;
+    }
+
+    class NestedMap extends CoMap<NestedMap> {
+        name = co.string;
+        twiceNested = co.ref(TwiceNestedMap);
+
+        get _fancyName() {
             return "Sir " + this.name;
         }
     }
 
-    class TestMap extends Co.map({
-        color: S.string,
-        height: S.number,
-        nested: NestedMap,
-    }).as<TestMap>() {
-        get roughColor() {
+    class TestMap extends CoMap<TestMap> {
+        color = co.string;
+        height = co.number;
+        nested = co.ref(NestedMap);
+
+        get _roughColor() {
             return this.color + "ish";
         }
     }
@@ -132,10 +219,10 @@ describe("CoMap resolution", async () => {
         // const test: Schema.Schema.To<typeof NestedMap>
 
         expect(map.color).toEqual("red");
-        expect(map.roughColor).toEqual("redish");
+        expect(map._roughColor).toEqual("redish");
         expect(map.height).toEqual(10);
         expect(map.nested?.name).toEqual("nested");
-        expect(map.nested?.fancyName).toEqual("Sir nested");
+        expect(map.nested?._fancyName).toEqual("Sir nested");
         expect(map.nested?.id).toBeDefined();
         expect(map.nested?.twiceNested?.taste).toEqual("sour");
     });
@@ -159,16 +246,16 @@ describe("CoMap resolution", async () => {
 
         expect(loadedMap?.color).toEqual("red");
         expect(loadedMap?.height).toEqual(10);
-        expect(loadedMap?.nested).toEqual(undefined);
+        expect(loadedMap?.nested).toEqual(null);
         expect(loadedMap?._refs.nested?.id).toEqual(map.nested?.id);
-        expect(loadedMap?._refs.nested?.value).toEqual(undefined);
+        expect(loadedMap?._refs.nested?.value).toEqual(null);
 
         const loadedNestedMap = await NestedMap.load(map.nested!.id, {
             as: meOnSecondPeer,
         });
 
         expect(loadedMap?.nested?.name).toEqual("nested");
-        expect(loadedMap?.nested.fancyName).toEqual("Sir nested");
+        expect(loadedMap?.nested?._fancyName).toEqual("Sir nested");
         expect(loadedMap?._refs.nested?.value).toEqual(loadedNestedMap);
         expect(loadedMap?.nested?.twiceNested?.taste).toEqual(undefined);
 
@@ -236,7 +323,7 @@ describe("CoMap resolution", async () => {
                 );
 
                 const update1 = yield* $(Queue.take(queue));
-                expect(update1.nested).toEqual(undefined);
+                expect(update1.nested).toEqual(null);
 
                 const update2 = yield* $(Queue.take(queue));
                 expect(update2.nested?.name).toEqual("nested");
@@ -287,10 +374,10 @@ describe("CoMap resolution", async () => {
         );
     });
 
-    class TestMapWithOptionalRef extends Co.map({
-        color: S.string,
-        nested: S.optional(NestedMap),
-    }).as<TestMapWithOptionalRef>() {}
+    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
+        color = co.string;
+        nested? = co.ref(NestedMap);
+    }
 
     test("Construction with optional", async () => {
         const me = await Account.create({
@@ -326,14 +413,14 @@ describe("CoMap resolution", async () => {
 
         expect(mapWith.color).toEqual("red");
         expect(mapWith.nested?.name).toEqual("wow!");
-        expect(mapWith.nested?.fancyName).toEqual("Sir wow!");
+        expect(mapWith.nested?._fancyName).toEqual("Sir wow!");
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends Co.map(
-        { color: S.string },
-        { key: S.string, value: S.string }
-    ).as<TestRecord>() {}
+    class TestRecord extends CoMap<TestRecord> {
+        [co.items] = co.number;
+    }
+    interface TestRecord extends Record<string, number> {}
 
     test("Construction with index signature", async () => {
         const me = await Account.create({
@@ -342,16 +429,16 @@ describe("CoMap resolution", async () => {
 
         const record = new TestRecord(
             {
-                color: "red",
-                other: "wild",
+                height: 5,
+                other: 3,
             },
             { owner: me }
         );
 
-        expect(record.color).toEqual("red");
-        expect(record._raw.get("color")).toEqual("red");
-        expect(record.other).toEqual("wild");
-        expect(record._raw.get("other")).toEqual("wild");
-        expect(Object.keys(record)).toEqual(["color", "other"]);
+        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"]);
     });
 });