jazz-tools 0.7.0-alpha.0

package/src/tests/coList.test.ts

@@ -0,0 +1,283 @@
+import { expect, describe, test, beforeEach } from "vitest";
+
+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 "..";
+
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
+beforeEach(async () => {
+    await jazzReady;
+});
+
+describe("Simple CoList operations", async () => {
+    const me = await Account.create({
+        name: "Hermes Puggington",
+    });
+
+    class TestList extends Co.list(S.string).as<TestList>() {}
+
+    const list = new TestList(["bread", "butter", "onion"], { owner: me });
+
+    test("Construction", () => {
+        expect(list[0]).toBe("bread");
+        expect(list[1]).toBe("butter");
+        expect(list[2]).toBe("onion");
+        expect(list._raw.asArray()).toEqual(["bread", "butter", "onion"]);
+        expect(list.length).toBe(3);
+        expect(list.map((item) => item.toUpperCase())).toEqual([
+            "BREAD",
+            "BUTTER",
+            "ONION",
+        ]);
+    });
+
+    describe("Mutation", () => {
+        test("assignment", () => {
+            const list = new TestList(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            list[1] = "margarine";
+            expect(list._raw.asArray()).toEqual([
+                "bread",
+                "margarine",
+                "onion",
+            ]);
+            expect(list[1]).toBe("margarine");
+        });
+
+        test("push", () => {
+            const list = new TestList(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            list.push("cheese");
+            expect(list[3]).toBe("cheese");
+            expect(list._raw.asArray()).toEqual([
+                "bread",
+                "butter",
+                "onion",
+                "cheese",
+            ]);
+        });
+
+        test("unshift", () => {
+            const list = new TestList(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            list.unshift("lettuce");
+            expect(list[0]).toBe("lettuce");
+            expect(list._raw.asArray()).toEqual([
+                "lettuce",
+                "bread",
+                "butter",
+                "onion",
+            ]);
+        });
+
+        test("pop", () => {
+            const list = new TestList(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            expect(list.pop()).toBe("onion");
+            expect(list.length).toBe(2);
+            expect(list._raw.asArray()).toEqual(["bread", "butter"]);
+        });
+
+        test("shift", () => {
+            const list = new TestList(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            expect(list.shift()).toBe("bread");
+            expect(list.length).toBe(2);
+            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",
+            ]);
+        });
+    });
+});
+
+describe("CoList resolution", async () => {
+    class TwiceNestedList extends Co.list(S.string).as<TwiceNestedList>() {
+        joined() {
+            return this.join(",");
+        }
+    }
+
+    class NestedList extends Co.list(TwiceNestedList).as<NestedList>() {}
+
+    class TestList extends Co.list(NestedList).as<TestList>() {}
+
+    const initNodeAndList = async () => {
+        const me = await Account.create({
+            name: "Hermes Puggington",
+        });
+
+        const list = new TestList(
+            [
+                new NestedList(
+                    [new TwiceNestedList(["a", "b"], { owner: me })],
+                    { owner: me }
+                ),
+                new NestedList(
+                    [new TwiceNestedList(["c", "d"], { owner: me })],
+                    { owner: me }
+                ),
+            ],
+            { owner: me }
+        );
+
+        return { me, list };
+    };
+
+    test("Construction", async () => {
+        const { list } = await initNodeAndList();
+
+        expect(list[0]?.[0]?.[0]).toBe("a");
+        expect(list[0]?.[0]?.joined()).toBe("a,b");
+        expect(list[0]?.[0]?.id).toBeDefined();
+        expect(list[1]?.[0]?.[0]).toBe("c");
+    });
+
+    test("Loading and availability", async () => {
+        const { me, list } = await initNodeAndList();
+
+        const [initialAsPeer, secondPeer] = connectedPeers(
+            "initial",
+            "second",
+            { peer1role: "server", peer2role: "client" }
+        );
+        me._raw.core.node.syncManager.addPeer(secondPeer);
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
+            peersToLoadFrom: [initialAsPeer],
+            sessionID: newRandomSessionID(me.id as any),
+        });
+
+        const loadedList = await TestList.load(list.id, { as: meOnSecondPeer });
+
+        expect(loadedList?.[0]).toBe(undefined);
+        expect(loadedList?._refs[0]?.id).toEqual(list[0]!.id);
+
+        const loadedNestedList = await NestedList.load(list[0]!.id, {
+            as: meOnSecondPeer,
+        });
+
+        expect(loadedList?.[0]).toBeDefined();
+        expect(loadedList?.[0]?.[0]).toBeUndefined();
+        expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]![0]!.id);
+        expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
+
+        const loadedTwiceNestedList = await TwiceNestedList.load(
+            list[0]![0]!.id,
+            { as: meOnSecondPeer }
+        );
+
+        expect(loadedList?.[0]?.[0]).toBeDefined();
+        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
+        );
+
+        const otherNestedList = new NestedList(
+            [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
+            { owner: meOnSecondPeer }
+        );
+
+        loadedList![0] = otherNestedList;
+        expect(loadedList?.[0]).toEqual(otherNestedList);
+        expect(loadedList?._refs[0]?.id).toEqual(otherNestedList.id);
+    });
+
+    test("Subscription & auto-resolution", async () => {
+        const { me, list } = await initNodeAndList();
+
+        const [initialAsPeer, secondPeer] = connectedPeers(
+            "initial",
+            "second",
+            { peer1role: "server", peer2role: "client" }
+        );
+        me._raw.core.node.syncManager.addPeer(secondPeer);
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
+            peersToLoadFrom: [initialAsPeer],
+            sessionID: newRandomSessionID(me.id as any),
+        });
+
+        await Effect.runPromise(
+            Effect.gen(function* ($) {
+                const queue = yield* $(Queue.unbounded<TestList>());
+
+                TestList.subscribe(
+                    list.id,
+                    { as: meOnSecondPeer },
+                    (subscribedList) => {
+                        console.log(
+                            "subscribedList?.[0]?.[0]?.[0]",
+                            subscribedList?.[0]?.[0]?.[0]
+                        );
+                        Effect.runPromise(Queue.offer(queue, subscribedList));
+                    }
+                );
+
+                const update1 = yield* $(Queue.take(queue));
+                expect(update1?.[0]).toEqual(undefined);
+
+                const update2 = yield* $(Queue.take(queue));
+                expect(update2?.[0]).toBeDefined();
+                expect(update2?.[0]?.[0]).toBeUndefined();
+
+                const update3 = yield* $(Queue.take(queue));
+                expect(update3?.[0]?.[0]).toBeDefined();
+                expect(update3?.[0]?.[0]?.[0]).toBe("a");
+                expect(update3?.[0]?.[0]?.joined()).toBe("a,b");
+
+                update3[0]![0]![0] = "x";
+
+                const update4 = yield* $(Queue.take(queue));
+                expect(update4?.[0]?.[0]?.[0]).toBe("x");
+
+                // When assigning a new nested value, we get an update
+
+                const newTwiceNestedList = new TwiceNestedList(["y", "z"], {
+                    owner: meOnSecondPeer,
+                });
+
+                const newNestedList = new NestedList([newTwiceNestedList], {
+                    owner: meOnSecondPeer,
+                });
+
+                update4[0] = newNestedList;
+
+                const update5 = yield* $(Queue.take(queue));
+                expect(update5?.[0]?.[0]?.[0]).toBe("y");
+                expect(update5?.[0]?.[0]?.joined()).toBe("y,z");
+
+                // we get updates when the new nested value changes
+                newTwiceNestedList[0] = "w";
+                const update6 = yield* $(Queue.take(queue));
+                expect(update6?.[0]?.[0]?.[0]).toBe("w");
+            })
+        );
+    });
+});

package/src/tests/coMap.test.ts

@@ -0,0 +1,357 @@
+import { expect, describe, test, beforeEach } from "vitest";
+
+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 "..";
+
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
+beforeEach(async () => {
+    await jazzReady;
+});
+
+describe("Simple CoMap operations", async () => {
+    const me = await Account.create({
+        name: "Hermes Puggington",
+    });
+
+    class TestMap extends Co.map({
+        color: S.string,
+        height: S.number,
+        birthday: S.Date,
+        name: S.optional(S.string),
+    }).as<TestMap>() {
+        get roughColor() {
+            return this.color + "ish";
+        }
+    }
+
+    const birthday = new Date();
+
+    const map = new TestMap(
+        {
+            color: "red",
+            height: 10,
+            birthday: birthday,
+        },
+        { owner: me }
+    );
+
+    test("Construction", () => {
+        expect(map.color).toEqual("red");
+        expect(map.roughColor).toEqual("redish");
+        expect(map.height).toEqual(10);
+        expect(map.birthday).toEqual(birthday);
+        expect(map._raw.get("birthday")).toEqual(birthday.toISOString());
+    });
+
+    describe("Mutation", () => {
+        test("assignment", () => {
+            map.color = "blue";
+            expect(map.color).toEqual("blue");
+            expect(map._raw.get("color")).toEqual("blue");
+            const newBirthday = new Date();
+            map.birthday = newBirthday;
+            expect(map.birthday).toEqual(newBirthday);
+            expect(map._raw.get("birthday")).toEqual(
+                newBirthday.toISOString()
+            );
+
+            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);
+
+            map.name = "Secret name";
+            expect(map.name).toEqual("Secret name");
+            delete map.name;
+            expect(map.name).toEqual(undefined);
+        });
+    });
+});
+
+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() {
+            return "Sir " + this.name;
+        }
+    }
+
+    class TestMap extends Co.map({
+        color: S.string,
+        height: S.number,
+        nested: NestedMap,
+    }).as<TestMap>() {
+        get roughColor() {
+            return this.color + "ish";
+        }
+    }
+
+    const initNodeAndMap = async () => {
+        const me = await Account.create({
+            name: "Hermes Puggington",
+        });
+
+        const map = new TestMap(
+            {
+                color: "red",
+                height: 10,
+                nested: new NestedMap(
+                    {
+                        name: "nested",
+                        twiceNested: new TwiceNestedMap(
+                            { taste: "sour" },
+                            { owner: me }
+                        ),
+                    },
+                    { owner: me }
+                ),
+            },
+            { owner: me }
+        );
+
+        return { me, map };
+    };
+
+    test("Construction", async () => {
+        const { map } = await initNodeAndMap();
+
+        // const test: Schema.Schema.To<typeof NestedMap>
+
+        expect(map.color).toEqual("red");
+        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?.id).toBeDefined();
+        expect(map.nested?.twiceNested?.taste).toEqual("sour");
+    });
+
+    test("Loading and availability", async () => {
+        const { me, map } = await initNodeAndMap();
+        const [initialAsPeer, secondPeer] = connectedPeers(
+            "initial",
+            "second",
+            { peer1role: "server", peer2role: "client" }
+        );
+        me._raw.core.node.syncManager.addPeer(secondPeer);
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
+            peersToLoadFrom: [initialAsPeer],
+            sessionID: newRandomSessionID(me.id as any),
+        });
+
+        const loadedMap = await TestMap.load(map.id, { as: meOnSecondPeer });
+
+        expect(loadedMap?.color).toEqual("red");
+        expect(loadedMap?.height).toEqual(10);
+        expect(loadedMap?.nested).toEqual(undefined);
+        expect(loadedMap?._refs.nested?.id).toEqual(map.nested?.id);
+        expect(loadedMap?._refs.nested?.value).toEqual(undefined);
+
+        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?._refs.nested?.value).toEqual(loadedNestedMap);
+        expect(loadedMap?.nested?.twiceNested?.taste).toEqual(undefined);
+
+        const loadedTwiceNestedMap = await TwiceNestedMap.load(
+            map.nested!.twiceNested!.id,
+            { as: meOnSecondPeer }
+        );
+
+        expect(loadedMap?.nested?.twiceNested?.taste).toEqual("sour");
+        expect(loadedMap?.nested?._refs.twiceNested?.value).toEqual(
+            loadedTwiceNestedMap
+        );
+
+        const otherNestedMap = new NestedMap(
+            {
+                name: "otherNested",
+                twiceNested: new TwiceNestedMap(
+                    { taste: "sweet" },
+                    { owner: meOnSecondPeer }
+                ),
+            },
+            { owner: meOnSecondPeer }
+        );
+
+        loadedMap!.nested = otherNestedMap;
+        expect(loadedMap?.nested?.name).toEqual("otherNested");
+        expect(loadedMap?._refs.nested?.id).toEqual(otherNestedMap.id);
+        expect(loadedMap?._refs.nested?.value).toEqual(otherNestedMap);
+        expect(loadedMap?.nested?.twiceNested?.taste).toEqual("sweet");
+        expect(loadedMap?.nested?._refs.twiceNested?.value).toBeDefined();
+    });
+
+    test("Subscription & auto-resolution", async () => {
+        const { me, map } = await initNodeAndMap();
+
+        const [initialAsPeer, secondAsPeer] = connectedPeers(
+            "initial",
+            "second",
+            { peer1role: "server", peer2role: "client" }
+        );
+
+        me._raw.core.node.syncManager.addPeer(secondAsPeer);
+
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
+            peersToLoadFrom: [initialAsPeer],
+            sessionID: newRandomSessionID(me.id as any),
+        });
+
+        await Effect.runPromise(
+            Effect.gen(function* ($) {
+                const queue = yield* $(Queue.unbounded<TestMap>());
+
+                TestMap.subscribe(
+                    map.id,
+                    { as: meOnSecondPeer },
+                    (subscribedMap) => {
+                        console.log(
+                            "subscribedMap.nested?.twiceNested?.taste",
+                            subscribedMap.nested?.twiceNested?.taste
+                        );
+                        Effect.runPromise(Queue.offer(queue, subscribedMap));
+                    }
+                );
+
+                const update1 = yield* $(Queue.take(queue));
+                expect(update1.nested).toEqual(undefined);
+
+                const update2 = yield* $(Queue.take(queue));
+                expect(update2.nested?.name).toEqual("nested");
+
+                map.nested!.name = "nestedUpdated";
+
+                const _ = yield* $(Queue.take(queue));
+                const update3 = yield* $(Queue.take(queue));
+                expect(update3.nested?.name).toEqual("nestedUpdated");
+
+                const oldTwiceNested = update3.nested!.twiceNested;
+                expect(oldTwiceNested?.taste).toEqual("sour");
+
+                // When assigning a new nested value, we get an update
+                const newTwiceNested = new TwiceNestedMap(
+                    {
+                        taste: "sweet",
+                    },
+                    { owner: meOnSecondPeer }
+                );
+
+                const newNested = new NestedMap(
+                    {
+                        name: "newNested",
+                        twiceNested: newTwiceNested,
+                    },
+                    { owner: meOnSecondPeer }
+                );
+
+                update3.nested = newNested;
+
+                yield* $(Queue.take(queue));
+                // const update4 = yield* $(Queue.take(queue));
+                const update4b = yield* $(Queue.take(queue));
+
+                expect(update4b.nested?.name).toEqual("newNested");
+                expect(update4b.nested?.twiceNested?.taste).toEqual("sweet");
+
+                // we get updates when the new nested value changes
+                newTwiceNested.taste = "salty";
+                const update5 = yield* $(Queue.take(queue));
+                expect(update5.nested?.twiceNested?.taste).toEqual("salty");
+
+                newTwiceNested.taste = "umami";
+                const update6 = yield* $(Queue.take(queue));
+                expect(update6.nested?.twiceNested?.taste).toEqual("umami");
+            })
+        );
+    });
+
+    class TestMapWithOptionalRef extends Co.map({
+        color: S.string,
+        nested: S.optional(NestedMap),
+    }).as<TestMapWithOptionalRef>() {}
+
+    test("Construction with optional", async () => {
+        const me = await Account.create({
+            name: "Hermes Puggington",
+        });
+
+        const mapWithout = new TestMapWithOptionalRef(
+            {
+                color: "red",
+            },
+            { owner: me }
+        );
+
+        expect(mapWithout.color).toEqual("red");
+        expect(mapWithout.nested).toEqual(undefined);
+
+        const mapWith = new TestMapWithOptionalRef(
+            {
+                color: "red",
+                nested: new NestedMap(
+                    {
+                        name: "wow!",
+                        twiceNested: new TwiceNestedMap(
+                            { taste: "sour" },
+                            { owner: me }
+                        ),
+                    },
+                    { owner: me }
+                ),
+            },
+            { owner: me }
+        );
+
+        expect(mapWith.color).toEqual("red");
+        expect(mapWith.nested?.name).toEqual("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>() {}
+
+    test("Construction with index signature", async () => {
+        const me = await Account.create({
+            name: "Hermes Puggington",
+        });
+
+        const record = new TestRecord(
+            {
+                color: "red",
+                other: "wild",
+            },
+            { 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"]);
+    });
+});