jazz-tools 0.7.0-alpha.6 → 0.7.0-alpha.8

package/src/implementation/refs.ts

@@ -5,7 +5,7 @@ import type {
     CoValue,
     ID,
     Me,
-    SubclassedConstructor,
+    RefEncoded,
     UnavailableError,
 } from "../internal.js";
 import { subscriptionsScopes } from "../internal.js";
@@ -16,8 +16,12 @@ export class Ref<V extends CoValue> {
     constructor(
         readonly id: ID<V>,
         readonly controlledAccount: Account & Me,
-        readonly valueConstructor: SubclassedConstructor<V>
-    ) {}
+        readonly encoding: RefEncoded<V>
+    ) {
+        if (!("ref" in encoding)) {
+            throw new Error("Ref must be constructed with a ref encoding");
+        }
+    }
 
     get value() {
         if (this.cachedValue) return this.cachedValue;
@@ -26,9 +30,7 @@ export class Ref<V extends CoValue> {
             this.id as unknown as CoID<RawCoValue>
         );
         if (raw) {
-            const value = new this.valueConstructor(undefined, {
-                fromRaw: raw,
-            }) as V;
+            const value = this.encoding.ref(raw).fromRaw(raw);
             this.cachedValue = value;
             return value;
         } else {
@@ -65,7 +67,7 @@ export class Ref<V extends CoValue> {
             return new Ref(
                 this.id,
                 this.controlledAccount,
-                this.valueConstructor
+                this.encoding
             ).value!;
         }
     }
@@ -98,7 +100,7 @@ export function makeRefs<Keys extends string | number>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
     controlledAccount: Account & Me,
-    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>
+    refEncodingForKey: (key: Keys) => RefEncoded<CoValue>
 ): { [K in Keys]: Ref<CoValue> } & {
     [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
     length: number;
@@ -115,7 +117,7 @@ export function makeRefs<Keys extends string | number>(
                         yield new Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            valueConstructorForKey(key)
+                            refEncodingForKey(key)
                         );
                     }
                 };
@@ -129,7 +131,7 @@ export function makeRefs<Keys extends string | number>(
             return new Ref(
                 id as ID<CoValue>,
                 controlledAccount,
-                valueConstructorForKey(key as Keys)
+                refEncodingForKey(key as Keys)
             );
         },
         ownKeys() {

package/src/index.ts

@@ -12,7 +12,7 @@ export {
 
 export { ID, CoValue } from "./internal.js";
 
-export { Encoders } from "./internal.js";
+export { Encoders, val } from "./internal.js";
 
 export { CoMap } from "./internal.js";
 export { CoList } from "./internal.js";

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, val, jazzReady } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,8 +20,7 @@ describe("Simple CoList operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestList extends CoList<string> {}
-    TestList.encoding({ _item: "json" });
+    class TestList extends CoList.Of(val.string) {}
 
     const list = new TestList(["bread", "butter", "onion"], { owner: me });
 
@@ -115,18 +114,15 @@ describe("Simple CoList operations", async () => {
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends CoList<string> {
+    class TwiceNestedList extends CoList.Of(val.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(val.ref(() => TwiceNestedList)) {}
 
-    class TestList extends CoList<NestedList | null> {}
-    TestList.encoding({ _item: { ref: () => NestedList } });
+    class TestList extends CoList.Of(val.ref(() => NestedList)) {}
 
     const initNodeAndList = async () => {
         const me = await Account.create({

package/src/tests/coMap.test.ts

@@ -5,6 +5,7 @@ import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
 import { Account, jazzReady, Encoders, CoMap } from "..";
+import { val } from "../internal";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -21,21 +22,15 @@ describe("Simple CoMap operations", async () => {
     });
 
     class TestMap extends CoMap<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare birthday: Date;
-        declare name?: string;
+        color = val.string;
+        _height = val.number;
+        birthday = val.encoded(Encoders.Date);
+        name? = val.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);
 
@@ -44,7 +39,7 @@ describe("Simple CoMap operations", async () => {
     const map = new TestMap(
         {
             color: "red",
-            height: 10,
+            _height: 10,
             birthday: birthday,
         },
         { owner: me }
@@ -52,10 +47,16 @@ 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",
+            "name",
+        ]);
     });
 
     describe("Mutation", () => {
@@ -68,11 +69,11 @@ 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");
@@ -82,13 +83,9 @@ describe("Simple CoMap operations", async () => {
     });
 
     class RecursiveMap extends CoMap<RecursiveMap> {
-        declare name: string;
-        declare next: RecursiveMap | null;
+        name = val.string;
+        next: val<RecursiveMap | null> = val.ref(() => RecursiveMap);
     }
-    RecursiveMap.encoding({
-        name: "json",
-        next: { ref: () => RecursiveMap },
-    });
 
     const recursiveMap = new RecursiveMap(
         {
@@ -116,43 +113,79 @@ describe("Simple CoMap operations", async () => {
             expect(recursiveMap.next?.next?.name).toEqual("third");
         });
     });
+
+    class MapWithEnumOfMaps extends CoMap<MapWithEnumOfMaps> {
+        name = val.string;
+        child = val.ref<typeof ChildA | typeof ChildB>((raw) =>
+            raw.get("type") === "a" ? ChildA : ChildB
+        );
+    }
+
+    class ChildA extends CoMap<ChildA> {
+        type = val.literal("a");
+        value = val.number;
+    }
+
+    class ChildB extends CoMap<ChildB> {
+        type = val.literal("b");
+        value = val.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 = val.string;
+    }
+
+    class SubClassMap extends SuperClassMap {
+        name = val.literal("specificString")
+        value = val.number;
+    }
+    interface SubClassMap extends CoMap<SubClassMap> {}
 });
 
 describe("CoMap resolution", async () => {
     class TwiceNestedMap extends CoMap<TwiceNestedMap> {
-        taste!: string;
+        taste = val.string;
     }
-    TwiceNestedMap.encoding({
-        taste: "json",
-    });
 
     class NestedMap extends CoMap<NestedMap> {
-        name!: string;
-        twiceNested!: TwiceNestedMap | null;
+        name = val.string;
+        twiceNested = val.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;
+        color = val.string;
+        height = val.number;
+        nested = val.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({
@@ -342,13 +375,9 @@ describe("CoMap resolution", async () => {
     });
 
     class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
-        declare color: string;
-        declare nested?: NestedMap | null;
+        color = val.string;
+        nested? = val.ref(() => NestedMap);
     }
-    TestMapWithOptionalRef.encoding({
-        color: "json",
-        nested: { ref: () => NestedMap },
-    });
 
     test("Construction with optional", async () => {
         const me = await Account.create({
@@ -389,12 +418,9 @@ describe("CoMap resolution", async () => {
     });
 
     class TestRecord extends CoMap<TestRecord> {
-        declare _item: number;
+        [val.items] = val.number;
     }
     interface TestRecord extends Record<string, number> {}
-    TestRecord.encoding({
-        _item: "json",
-    });
 
     test("Construction with index signature", async () => {
         const me = await Account.create({

package/src/tests/coStream.test.ts

@@ -1,10 +1,10 @@
-import { expect, describe, test, beforeEach, Test } from "vitest";
+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 { BinaryCoStream, ID, Account, jazzReady, CoStream } from "..";
+import { BinaryCoStream, ID, Account, jazzReady, CoStream, val } from "..";
 import { Simplify } from "effect/Types";
 
 if (!("crypto" in globalThis)) {
@@ -21,42 +21,38 @@ describe("Simple CoStream operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestStream extends CoStream<string> {}
-    TestStream.encoding({ _item: "json" });
+    class TestStream extends CoStream.Of(val.string) {}
 
     const stream = new TestStream(["milk"], { owner: me });
 
     test("Construction", () => {
-        expect(stream.by[me.id]?.value).toEqual("milk");
-        expect(stream.in[me.sessionID]?.value).toEqual("milk");
+        expect(stream[me.id]?.value).toEqual("milk");
+        expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
     });
 
     describe("Mutation", () => {
         test("pushing", () => {
             stream.push("bread");
-            expect(stream.by[me.id]?.value).toEqual("bread");
-            expect(stream.in[me.sessionID]?.value).toEqual("bread");
+            expect(stream[me.id]?.value).toEqual("bread");
+            expect(stream.perSession[me.sessionID]?.value).toEqual("bread");
 
             stream.push("butter");
-            expect(stream.by[me.id]?.value).toEqual("butter");
-            expect(stream.in[me.sessionID]?.value).toEqual("butter");
+            expect(stream[me.id]?.value).toEqual("butter");
+            expect(stream.perSession[me.sessionID]?.value).toEqual("butter");
         });
     });
 });
 
 describe("CoStream resolution", async () => {
-    class TwiceNestedStream extends CoStream<string> {
+    class TwiceNestedStream extends CoStream.Of(val.string) {
         fancyValueOf(account: ID<Account>) {
-            return "Sir " + this.by[account]?.value;
+            return "Sir " + this[account]?.value;
         }
     }
-    TwiceNestedStream.encoding({ _item: "json" });
 
-    class NestedStream extends CoStream<TwiceNestedStream | null>{}
-    NestedStream.encoding({ _item: {ref: () => TwiceNestedStream} });
+    class NestedStream extends CoStream.Of(val.ref(() => TwiceNestedStream)) {}
 
-    class TestStream extends CoStream<NestedStream | null> {}
-    TestStream.encoding({ _item: {ref: () => NestedStream} });
+    class TestStream extends CoStream.Of(val.ref(() => NestedStream)) {}
 
     const initNodeAndStream = async () => {
         const me = await Account.create({
@@ -78,9 +74,9 @@ describe("CoStream resolution", async () => {
 
     test("Construction", async () => {
         const { me, stream } = await initNodeAndStream();
-        expect(
-            stream.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value
-        ).toEqual("milk");
+        expect(stream[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toEqual(
+            "milk"
+        );
     });
 
     test("Loading and availability", async () => {
@@ -102,48 +98,48 @@ describe("CoStream resolution", async () => {
             as: meOnSecondPeer,
         });
 
-        expect(loadedStream?.by[me.id]?.value).toEqual(null);
-        expect(loadedStream?.by[me.id]?.ref?.id).toEqual(
-            stream.by[me.id]?.value?.id
+        expect(loadedStream?.[me.id]?.value).toEqual(null);
+        expect(loadedStream?.[me.id]?.ref?.id).toEqual(
+            stream[me.id]?.value?.id
         );
 
         const loadedNestedStream = await NestedStream.load(
-            stream.by[me.id]!.value!.id,
+            stream[me.id]!.value!.id,
             { as: meOnSecondPeer }
         );
 
-        // expect(loadedStream?.by[me.id]?.value).toEqual(loadedNestedStream);
-        expect(loadedStream?.by[me.id]?.value?.id).toEqual(
+        // expect(loadedStream?.[me.id]?.value).toEqual(loadedNestedStream);
+        expect(loadedStream?.[me.id]?.value?.id).toEqual(
             loadedNestedStream?.id
         );
-        expect(loadedStream?.by[me.id]?.value?.by[me.id]?.value).toEqual(null);
-        // expect(loadedStream?.by[me.id]?.ref?.value).toEqual(loadedNestedStream);
-        expect(loadedStream?.by[me.id]?.ref?.value?.id).toEqual(
+        expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(null);
+        // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
+        expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
             loadedNestedStream?.id
         );
-        expect(loadedStream?.by[me.id]?.value?.by[me.id]?.ref?.id).toEqual(
-            stream.by[me.id]?.value?.by[me.id]?.value?.id
+        expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.id).toEqual(
+            stream[me.id]?.value?.[me.id]?.value?.id
         );
 
         const loadedTwiceNestedStream = await TwiceNestedStream.load(
-            stream.by[me.id]!.value!.by[me.id]!.value!.id,
+            stream[me.id]!.value![me.id]!.value!.id,
             { as: meOnSecondPeer }
         );
 
-        // expect(loadedStream?.by[me.id]?.value?.by[me.id]?.value).toEqual(
+        // expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(
         //     loadedTwiceNestedStream
         // );
-        expect(loadedStream?.by[me.id]?.value?.by[me.id]?.value?.id).toEqual(
+        expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
             loadedTwiceNestedStream?.id
         );
         expect(
-            loadedStream?.by[me.id]?.value?.by[me.id]?.value?.fancyValueOf(
-                me.id
-            )
+            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id)
         ).toEqual("Sir milk");
-        // expect(loadedStream?.by[me.id]?.ref?.value).toEqual(loadedNestedStream);
-        expect(loadedStream?.by[me.id]?.ref?.value?.id).toEqual(loadedNestedStream?.id);
-        expect(loadedStream?.by[me.id]?.value?.by[me.id]?.ref?.value?.id).toEqual(
+        // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
+        expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
+            loadedNestedStream?.id
+        );
+        expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.value?.id).toEqual(
             loadedTwiceNestedStream?.id
         );
 
@@ -152,16 +148,16 @@ describe("CoStream resolution", async () => {
             { owner: meOnSecondPeer }
         );
         loadedStream?.push(otherNestedStream);
-        // expect(loadedStream?.by[me.id]?.value).toEqual(otherNestedStream);
-        expect(loadedStream?.by[me.id]?.value?.id).toEqual(otherNestedStream?.id);
-        expect(loadedStream?.by[me.id]?.ref?.value?.id).toEqual(otherNestedStream?.id);
-        expect(loadedStream?.by[me.id]?.value?.by[me.id]?.value?.id).toEqual(
-            otherNestedStream.by[me.id]?.value?.id
+        // expect(loadedStream?.[me.id]?.value).toEqual(otherNestedStream);
+        expect(loadedStream?.[me.id]?.value?.id).toEqual(otherNestedStream?.id);
+        expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
+            otherNestedStream?.id
+        );
+        expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
+            otherNestedStream[me.id]?.value?.id
         );
         expect(
-            loadedStream?.by[me.id]?.value?.by[me.id]?.value?.fancyValueOf(
-                me.id
-            )
+            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id)
         ).toEqual("Sir butter");
     });
 
@@ -192,17 +188,18 @@ describe("CoStream resolution", async () => {
                     { as: meOnSecondPeer },
                     (subscribedStream) => {
                         console.log(
-                            "subscribedStream.by[me.id]",
-                            subscribedStream.by[me.id]
+                            "subscribedStream[me.id]",
+                            subscribedStream[me.id]
                         );
                         console.log(
-                            "subscribedStream.by[me.id]?.value?.by[me.id]?.value",
-                            subscribedStream.by[me.id]?.value?.by[me.id]?.value
+                            "subscribedStream[me.id]?.value?.[me.id]?.value",
+                            subscribedStream[me.id]?.value?.[me.id]?.value
                         );
                         console.log(
-                            "subscribedStream.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value",
-                            subscribedStream.by[me.id]?.value?.by[me.id]?.value
-                                ?.by[me.id]?.value
+                            "subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value",
+                            subscribedStream[me.id]?.value?.[me.id]?.value?.[
+                                me.id
+                            ]?.value
                         );
                         Effect.runPromise(Queue.offer(queue, subscribedStream));
                     }
@@ -212,25 +209,23 @@ describe("CoStream resolution", async () => {
                 const te: T = stream;
 
                 const update1 = yield* $(Queue.take(queue));
-                expect(update1.by[me.id]?.value).toEqual(null);
+                expect(update1[me.id]?.value).toEqual(null);
 
                 const update2 = yield* $(Queue.take(queue));
-                expect(update2.by[me.id]?.value).toBeDefined();
-                expect(update2.by[me.id]?.value?.by[me.id]?.value).toBe(null);
+                expect(update2[me.id]?.value).toBeDefined();
+                expect(update2[me.id]?.value?.[me.id]?.value).toBe(null);
 
                 const update3 = yield* $(Queue.take(queue));
+                expect(update3[me.id]?.value?.[me.id]?.value).toBeDefined();
                 expect(
-                    update3.by[me.id]?.value?.by[me.id]?.value
-                ).toBeDefined();
-                expect(
-                    update3.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value
+                    update3[me.id]?.value?.[me.id]?.value?.[me.id]?.value
                 ).toBe("milk");
 
-                update3.by[me.id]!.value!.by[me.id]!.value!.push("bread");
+                update3[me.id]!.value![me.id]!.value!.push("bread");
 
                 const update4 = yield* $(Queue.take(queue));
                 expect(
-                    update4.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value
+                    update4[me.id]?.value?.[me.id]?.value?.[me.id]?.value
                 ).toBe("bread");
 
                 // When assigning a new nested stream, we get an update
@@ -246,14 +241,14 @@ describe("CoStream resolution", async () => {
 
                 const update5 = yield* $(Queue.take(queue));
                 expect(
-                    update5.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value
+                    update5[me.id]?.value?.[me.id]?.value?.[me.id]?.value
                 ).toBe("butter");
 
                 // we get updates when the new nested stream changes
                 newTwiceNested.push("jam");
                 const update6 = yield* $(Queue.take(queue));
                 expect(
-                    update6.by[me.id]?.value?.by[me.id]?.value?.by[me.id]?.value
+                    update6[me.id]?.value?.[me.id]?.value?.[me.id]?.value
                 ).toBe("jam");
             })
         );