jazz-tools 0.7.0-alpha.1 → 0.7.0-alpha.12

package/src/implementation/refs.ts

@@ -1,16 +1,31 @@
 import { Effect } from "effect";
 import type { CoID, RawCoValue } from "cojson";
-import type { Account, CoValue, ID, Me, SubclassedConstructor, UnavailableError, indexSignature} from '../internal.js';
-import { subscriptionsScopes } from '../internal.js';
+import type {
+    Account,
+    CoValue,
+    ID,
+    Me,
+    RefEncoded,
+    UnavailableError,
+} from "../internal.js";
+import {
+    instantiateRefEncoded,
+    isRefEncoded,
+    subscriptionsScopes,
+} from "../internal.js";
 
-export class ValueRef<V extends CoValue> {
+export class Ref<V extends CoValue> {
     private cachedValue: V | undefined;
 
     constructor(
         readonly id: ID<V>,
         readonly controlledAccount: Account & Me,
-        readonly valueConstructor: SubclassedConstructor<V>
-    ) {}
+        readonly schema: RefEncoded<V>
+    ) {
+        if (!isRefEncoded(schema)) {
+            throw new Error("Ref must be constructed with a ref schema");
+        }
+    }
 
     get value() {
         if (this.cachedValue) return this.cachedValue;
@@ -19,7 +34,7 @@ export class ValueRef<V extends CoValue> {
             this.id as unknown as CoID<RawCoValue>
         );
         if (raw) {
-            const value = new this.valueConstructor(undefined, { fromRaw: raw }) as V;
+            const value = instantiateRefEncoded(this.schema, raw);
             this.cachedValue = value;
             return value;
         } else {
@@ -43,7 +58,9 @@ export class ValueRef<V extends CoValue> {
         });
     }
 
-    private async loadHelper(options?: {onProgress: (p: number) => void}): Promise<V | "unavailable"> {
+    private async loadHelper(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | "unavailable"> {
         const raw = await this.controlledAccount._raw.core.node.load(
             this.id as unknown as CoID<RawCoValue>,
             options?.onProgress
@@ -51,12 +68,14 @@ export class ValueRef<V extends CoValue> {
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(this.id, this.controlledAccount, this.valueConstructor)
+            return new Ref(this.id, this.controlledAccount, this.schema)
                 .value!;
         }
     }
 
-    async load(options?: {onProgress: (p: number) => void}): Promise<V | undefined> {
+    async load(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | undefined> {
         const result = await this.loadHelper(options);
         if (result === "unavailable") {
             return undefined;
@@ -78,22 +97,28 @@ export class ValueRef<V extends CoValue> {
     }
 }
 
-export function makeRefs<Keys extends string | number | indexSignature>(
+export function makeRefs<Keys extends string | number>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
     controlledAccount: Account & Me,
-    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>,
-): { [K in Keys]: ValueRef<CoValue> } {
-    const refs = {} as { [K in Keys]: ValueRef<CoValue> };
+    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>
+): { [K in Keys]: Ref<CoValue> } & {
+    [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
+    length: number;
+} {
+    const refs = {} as { [K in Keys]: Ref<CoValue> } & {
+        [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
+        length: number;
+    };
     return new Proxy(refs, {
-        get(target, key) {
+        get(_target, key) {
             if (key === Symbol.iterator) {
                 return function* () {
                     for (const key of getKeysWithIds()) {
-                        yield new ValueRef(
+                        yield new Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            valueConstructorForKey(key)
+                            refSchemaForKey(key)
                         );
                     }
                 };
@@ -104,10 +129,10 @@ export function makeRefs<Keys extends string | number | indexSignature>(
             }
             const id = getIdForKey(key as Keys);
             if (!id) return undefined;
-            return new ValueRef(
+            return new Ref(
                 id as ID<CoValue>,
                 controlledAccount,
-                valueConstructorForKey(key as Keys)
+                refSchemaForKey(key as Keys)
             );
         },
         ownKeys() {

package/src/implementation/schema.ts

@@ -1,25 +1,81 @@
-import type { JsonValue } from "cojson";
-import type { CoValue, CoValueClass } from "../internal.js";
-import type { Schema, TypeId } from "@effect/schema/Schema";
-
-export type PrimitiveField = "json";
-export type EncodedField<V> = { encoded: Encoder<V> };
-export type RefField<V extends CoValue> = {
-    ref: () => CoValueClass<V>;
+import type { JsonValue, RawCoValue } from "cojson";
+import { type CoValue, type CoValueClass, isCoValueClass } from "../internal.js";
+import type { Schema as EffectSchema,  TypeId } from "@effect/schema/Schema";
+
+export type CoMarker = { readonly __co: unique symbol };
+export type co<T> = T | (T & CoMarker);
+export type IfCo<C, R> = C extends infer _A | infer B
+    ? B extends CoMarker
+        ? R
+        : never
+    : never;
+
+export const SchemaInit = Symbol.for("SchemaInit");
+export type SchemaInit = typeof SchemaInit;
+
+export const InitValues = Symbol.for("InitValues");
+export type InitValues = typeof InitValues;
+
+export const ItemsSym = Symbol.for("items");
+export type ItemsSym = typeof ItemsSym;
+
+export const co = {
+    string: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<string>,
+    number: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<number>,
+    boolean: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<boolean>,
+    literal: <T extends string | number | boolean>(_lit: T): co<T> => {
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    json: <T extends JsonValue>(): co<T> => {
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    encoded: <T>(arg: Encoder<T>): co<T> => {
+        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+    },
+    ref: <C extends CoValueClass>(
+        arg: C | ((_raw: InstanceType<C>["_raw"]) => C)
+    ): co<InstanceType<C> | null> => {
+        return { [SchemaInit]: arg satisfies Schema } as any;
+    },
+    items: ItemsSym as ItemsSym,
 };
 
-export type FieldDescriptor =
-    | PrimitiveField
-    | RefField<CoValue>
-    | EncodedField<any>;
+export type JsonEncoded = "json";
+export type EncodedAs<V> = { encoded: Encoder<V> };
+export type RefEncoded<V extends CoValue> =
+    | CoValueClass<V>
+    | ((raw: RawCoValue) => CoValueClass<V>);
 
-export type FieldDescriptorFor<Field> = NonNullable<Field> extends CoValue
-    ? RefField<NonNullable<Field>>
+export function isRefEncoded<V extends CoValue>(
+    schema: Schema
+): schema is RefEncoded<V> {
+    return typeof schema === "function";
+}
+
+export function instantiateRefEncoded<V extends CoValue>(
+    schema: RefEncoded<V>,
+    raw: RawCoValue
+): V {
+    return isCoValueClass(schema)
+        ? schema.fromRaw(raw)
+        : (schema as (raw: RawCoValue) => CoValueClass<V>)(raw).fromRaw(raw);
+}
+
+export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
+
+export type SchemaFor<Field> = NonNullable<Field> extends CoValue
+    ? RefEncoded<NonNullable<Field>>
     : NonNullable<Field> extends JsonValue
-      ? PrimitiveField
-      : EncodedField<NonNullable<Field>>;
+      ? JsonEncoded
+      : EncodedAs<NonNullable<Field>>;
 
-export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
+export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
     any,
     any,
     never
@@ -38,12 +94,9 @@ export const Encoders = {
     Date,
 };
 
-export const indexSignature = Symbol.for("indexSignature");
-export type indexSignature = typeof indexSignature;
-
 export type EnsureCoValueNullable<
     V,
-    Key extends string | indexSignature,
+    Key extends string | ItemsSym,
 > = NonNullable<V> extends CoValue
     ? null extends V
         ? V
@@ -53,17 +106,19 @@ export type EnsureCoValueNullable<
                 V | null,
             ]
           : [
-                `👋 CoMap fields that are CoValue references should be nullable, declare [indexSignature] as:`,
+                `👋 CoMap fields that are CoValue references should be nullable, declare _item as:`,
                 V | null,
             ]
     : V;
 
-export type EnsureItemNullable<Item, ContainerType extends string> =
-    NonNullable<Item> extends CoValue
-        ? null extends Item
-            ? any
-            : [
-                  `👋 CoList items that are CoValue references should be nullable, make sure the Item generic parameter of ${ContainerType} is:`,
-                  Item | null
-              ]
-        : any;
+export type ValidItem<
+    Item,
+    ContainerType extends string,
+> = NonNullable<Item> extends CoValue
+    ? null extends Item
+        ? any
+        : [
+              `👋 CoList items that are CoValue references should be nullable, make sure the Item generic parameter of ${ContainerType} is:`,
+              Item | null,
+          ]
+    : any;

package/src/index.ts

@@ -1,40 +1,25 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-import { BinaryCoStream, CoMap, ImageDefinition, Account as Account_, Group as Group_, CoList, CoStream } from "./internal.js";
-
-/** @category Schemas & CoValues - Schema definers */
-export namespace Co {
-    export const Map = CoMap;
-    export const List = CoList;
-    export const Stream = CoStream;
-    export const BinaryStream = BinaryCoStream;
-    export const Account = Account_;
-    export const Group = Group_;
-    export namespace media {
-        export const ImageDef = ImageDefinition;
-        export type ImageDef = ImageDefinition;
-    }
-}
-
-/** @category Internal types */
 export {
+    /** @category Internal types */
     cojsonReady as jazzReady,
+    cojsonInternals,
+    MAX_RECOMMENDED_TX_SIZE,
+} from "cojson";
+export type {
     InviteSecret,
     Peer,
     SessionID,
     AgentID,
     SyncMessage,
-    cojsonInternals,
-    MAX_RECOMMENDED_TX_SIZE,
 } from "cojson";
 
-export { ID, CoValue } from "./internal.js";
+export type { ID, CoValue } from "./internal.js";
 
-export { Encoders } from "./internal.js";
+export { Encoders, co } from "./internal.js";
 
-export { CoMap, indexSignature } from "./internal.js";
+export { CoMap } from "./internal.js";
 export { CoList } from "./internal.js";
 export { CoStream, BinaryCoStream } from "./internal.js";
 export { Group, Profile } from "./internal.js";
-export { Account, Me } from "./internal.js";
+export { Account, type Me } from "./internal.js";
 export { ImageDefinition } from "./internal.js";
-export { CoValueBase, CoValueClass } from "./internal.js";
+export { CoValueBase, type CoValueClass } 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 { Co, Account, jazzReady } from "..";
+import { Account, CoList, co, 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 Co.List<string> {}
-    TestList.encoding({ _item: "json" });
+    class TestList extends CoList.Of(co.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 Co.List<string> {
+    class TwiceNestedList extends CoList.Of(co.string) {
         joined() {
             return this.join(",");
         }
     }
-    TwiceNestedList.encoding({ _item: "json" });
 
-    class NestedList extends Co.List<TwiceNestedList | null> {}
-    NestedList.encoding({ _item: { ref: () => TwiceNestedList } });
+    class NestedList extends CoList.Of(co.ref(TwiceNestedList)) {}
 
-    class TestList extends Co.List<NestedList | null> {}
-    TestList.encoding({ _item: { ref: () => NestedList } });
+    class TestList extends CoList.Of(co.ref(NestedList)) {}
 
     const initNodeAndList = async () => {
         const me = await Account.create({

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, Account, jazzReady, Encoders, indexSignature } from "..";
+import { Account, jazzReady, Encoders, CoMap, co } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,24 +20,15 @@ describe("Simple CoMap operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestMap extends Co.Map<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare birthday: Date;
-        declare name?: string;
+    class TestMap extends CoMap<TestMap> {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
 
-        get _roughColor() {
+        get roughColor() {
             return this.color + "ish";
         }
-
-        static {
-            this.encoding({
-                color: "json",
-                height: "json",
-                birthday: { encoded: Encoders.Date },
-                name: "json",
-            });
-        }
     }
 
     console.log("TestMap schema", TestMap.prototype._schema);
@@ -47,7 +38,7 @@ describe("Simple CoMap operations", async () => {
     const map = new TestMap(
         {
             color: "red",
-            height: 10,
+            _height: 10,
             birthday: birthday,
         },
         { owner: me }
@@ -55,10 +46,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", () => {
@@ -71,11 +68,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");
@@ -84,17 +81,11 @@ describe("Simple CoMap operations", async () => {
         });
     });
 
-    class RecursiveMap extends Co.Map<RecursiveMap> {
-        declare name: string;
-        declare next: RecursiveMap | null;
-
-        static {
-            this.encoding({
-                name: "json",
-                next: { ref: () => RecursiveMap },
-            });
-        }
+    class RecursiveMap extends CoMap<RecursiveMap> {
+        name = co.string;
+        next: co<RecursiveMap | null> = co.ref(RecursiveMap);
     }
+
     const recursiveMap = new RecursiveMap(
         {
             name: "first",
@@ -121,41 +112,75 @@ describe("Simple CoMap operations", async () => {
             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<TwiceNestedMap> {
-        taste!: string;
+    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
+        taste = co.string;
     }
-    TwiceNestedMap.encoding({
-        taste: "json",
-    });
 
-    class NestedMap extends Co.Map<NestedMap> {
-        name!: string;
-        twiceNested!: TwiceNestedMap | null;
+    class NestedMap extends CoMap<NestedMap> {
+        name = co.string;
+        twiceNested = co.ref(TwiceNestedMap);
 
         get _fancyName() {
             return "Sir " + this.name;
         }
     }
-    NestedMap.encoding({
-        name: "json",
-        twiceNested: { ref: () => TwiceNestedMap },
-    });
 
-    class TestMap extends Co.Map<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare nested: NestedMap | null;
-
-        static {
-            this.encoding({
-                color: "json",
-                height: "json",
-                nested: { ref: () => NestedMap },
-            });
-        }
+    class TestMap extends CoMap<TestMap> {
+        color = co.string;
+        height = co.number;
+        nested = co.ref(NestedMap);
 
         get _roughColor() {
             return this.color + "ish";
@@ -349,16 +374,9 @@ describe("CoMap resolution", async () => {
         );
     });
 
-    class TestMapWithOptionalRef extends Co.Map<TestMapWithOptionalRef> {
-        declare color: string;
-        declare nested?: NestedMap | null;
-
-        static {
-            this.encoding({
-                color: "json",
-                nested: { ref: () => NestedMap },
-            });
-        }
+    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
+        color = co.string;
+        nested? = co.ref(NestedMap);
     }
 
     test("Construction with optional", async () => {
@@ -399,14 +417,8 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends Co.Map<TestRecord> {
-        declare [indexSignature]: number;
-
-        static {
-            this.encoding({
-                [indexSignature]: "json"
-            });
-        }
+    class TestRecord extends CoMap<TestRecord> {
+        [co.items] = co.number;
     }
     interface TestRecord extends Record<string, number> {}