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

package/src/coValues/coMap.ts

@@ -1,148 +1,110 @@
 import type { JsonValue, RawCoMap } from "cojson";
 import type { Simplify } from "effect/Types";
-import { Schema } from "@effect/schema";
+import { encodeSync, decodeSync } from "@effect/schema/Schema";
 import type {
     CoValue,
-    Encoder,
-    FieldDescriptor,
-    FieldDescriptorFor,
+    Schema,
     Group,
     ID,
-    RefField,
-    EnsureCoValueNullable,
-    CoValueClass,
+    RefEncoded,
+    IfCo,
+    RefIfCoValue,
+    SubclassedConstructor,
 } from "../internal.js";
 import {
     Account,
     CoValueBase,
-    ValueRef,
+    Ref,
+    SchemaInit,
     inspect,
     makeRefs,
     subscriptionsScopes,
-    indexSignature,
+    ItemsSym,
+    InitValues,
+    isRefEncoded,
 } from "../internal.js";
 
-type EnsureValid<
-    Fields extends { [key: string]: any; [indexSignature]?: any },
-> = {
-    [Key in OwnKeys<Fields> as IfOptionalKey<
-        Key,
-        Fields
-    >]?: EnsureCoValueNullable<Fields[Key], Key>;
-} & {
-    [Key in OwnKeys<Fields> as IfRequiredKey<
-        Key,
-        Fields
-    >]: EnsureCoValueNullable<Fields[Key], Key>;
-} & {
-    [Key in indexSignature]?: EnsureCoValueNullable<
-        Fields[indexSignature],
-        Key
-    >;
+type CoMapEdit<V> = {
+    value?: V;
+    ref?: RefIfCoValue<V>;
+    by?: Account;
+    madeAt: Date;
 };
 
-type IfOptionalKey<Key extends keyof Obj, Obj> = Pick<
-    Partial<Obj>,
-    Key
-> extends Pick<Obj, Key>
-    ? Key
-    : never;
-type IfRequiredKey<Key extends keyof Obj, Obj> = Pick<
-    Partial<Obj>,
-    Key
-> extends Pick<Obj, Key>
-    ? never
-    : Key;
-
-type DefaultFields = {
-    [key: string]: any;
-    [indexSignature]?: any;
+type InitValuesFor<C extends CoMap> = {
+    init: Simplify<CoMapInit<C>>;
+    owner: Account | Group;
 };
 
-export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
-    extends CoValueBase
-    implements CoValue<"CoMap", RawCoMap>
-{
-    id!: ID<this>;
-    _type!: "CoMap";
+export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
+    declare id: ID<this>;
+    declare _type: "CoMap";
     static {
         this.prototype._type = "CoMap";
     }
-    _raw!: RawCoMap;
-
-    static _encoding: any;
-    get _encoding(): {
-        [Key in OwnKeys<Fields>]: FieldDescriptorFor<Fields[Key]>;
-    } & {
-        [indexSignature]: indexSignature extends keyof Fields
-            ? FieldDescriptorFor<Fields[indexSignature]>
-            : never;
-    } {
-        return (this.constructor as typeof CoMap)._encoding;
+    declare _raw: RawCoMap;
+
+    static _schema: any;
+    get _schema() {
+        return (this.constructor as typeof CoMap)._schema as {
+            [key: string]: Schema;
+        } & { [ItemsSym]?: Schema };
     }
 
     get _refs(): {
-        [Key in OwnKeys<Fields> as NonNullable<Fields[Key]> extends CoValue
-            ? Key
-            : never]: NonNullable<Fields[Key]> extends CoValue
-            ? ValueRef<NonNullable<Fields[Key]>>
-            : never;
+        [Key in CoKeys<this>]: IfCo<this[Key], RefIfCoValue<this[Key]>>;
     } {
-        return makeRefs<OwnKeys<Fields>>(
+        return makeRefs<CoKeys<this>>(
             (key) => this._raw.get(key as string) as unknown as ID<CoValue>,
-            () =>
-                Object.keys(this._encoding).filter((key) => {
-                    const schema = this._encoding[
-                        key as keyof typeof this._encoding
-                    ] as FieldDescriptor;
-                    schema !== "json" && "ref" in schema;
-                }) as OwnKeys<Fields>[],
+            () => {
+                const keys = this._raw.keys().filter((key) => {
+                    const schema =
+                        this._schema[key as keyof typeof this._schema] ||
+                        (this._schema[ItemsSym] as Schema | undefined);
+                    return schema && schema !== "json" && isRefEncoded(schema);
+                }) as CoKeys<this>[];
+
+                return keys;
+            },
             this._loadedAs,
-            (key) => (this._encoding[key] as RefField<CoValue>).ref()
+            (key) =>
+                (this._schema[key] ||
+                    this._schema[ItemsSym]) as RefEncoded<CoValue>
         ) as any;
     }
 
-    get _edits(): {
-        [Key in OwnKeys<Fields>]: {
-            value?: Fields[Key];
-            ref?: Fields[Key] extends CoValue ? ValueRef<Fields[Key]> : never;
-            by?: Account;
-            madeAt: Date;
-        };
-    } {
+    get _edits() {
         return new Proxy(this, {
             get(target, key) {
                 const rawEdit = target._raw.lastEditAt(key as string);
                 if (!rawEdit) return undefined;
 
-                const descriptor = target._encoding[
-                    key as keyof typeof target._encoding
-                ] as FieldDescriptor;
+                const descriptor = target._schema[
+                    key as keyof typeof target._schema
+                ] as Schema;
 
                 return {
                     value:
                         descriptor === "json"
                             ? rawEdit.value
                             : "encoded" in descriptor
-                              ? Schema.decodeSync(descriptor.encoded)(
-                                    rawEdit.value
-                                )
-                              : new ValueRef(
+                              ? decodeSync(descriptor.encoded)(rawEdit.value)
+                              : new Ref(
                                     rawEdit.value as ID<CoValue>,
                                     target._loadedAs,
-                                    descriptor.ref()
+                                    descriptor
                                 ).accessFrom(target),
                     ref:
-                        descriptor !== "json" && "ref" in descriptor
-                            ? new ValueRef(
+                        descriptor !== "json" && isRefEncoded(descriptor)
+                            ? new Ref(
                                   rawEdit.value as ID<CoValue>,
                                   target._loadedAs,
-                                  descriptor.ref()
+                                  descriptor
                               )
                             : undefined,
                     by:
                         rawEdit.by &&
-                        new ValueRef(
+                        new Ref(
                             rawEdit.by as ID<Account>,
                             target._loadedAs,
                             Account
@@ -150,57 +112,59 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
                     madeAt: rawEdit.at,
                 };
             },
-        }) as any;
+        }) as {
+            [Key in CoKeys<this>]: IfCo<this[Key], CoMapEdit<this[Key]>>;
+        };
     }
 
     get _loadedAs() {
         return Account.fromNode(this._raw.core.node);
     }
 
-    constructor(_init: undefined, options: { fromRaw: RawCoMap });
-    constructor(
-        init: Simplify<CoMapInit<Fields>>,
-        options: { owner: Account | Group }
-    );
+    [InitValues]?: any;
+
     constructor(
-        init: Simplify<CoMapInit<Fields>> | undefined,
-        options: { owner: Account | Group } | { fromRaw: RawCoMap }
+        options: { fromRaw: RawCoMap } | { init: any; owner: Account | Group }
     ) {
         super();
 
-        if (!this._encoding) {
-            throw new Error(
-                "No schema found in " +
-                    this.constructor.name +
-                    " - ensure that you have a `static { this.define({...}) }` block in the class definition."
-            );
+        if ("owner" in options) {
+            this[InitValues] = {
+                init: options.init,
+                owner: options.owner,
+            } as InitValuesFor<this>;
+        } else if ("fromRaw" in options) {
+            Object.defineProperties(this, {
+                id: {
+                    value: options.fromRaw.id as unknown as ID<this>,
+                    enumerable: false,
+                },
+                _raw: { value: options.fromRaw, enumerable: false },
+            });
+        } else {
+            throw new Error("Invalid CoMap constructor arguments");
         }
 
-        const raw: RawCoMap = this.rawFromInit<Fields>(options, init);
-
-        Object.defineProperties(this, {
-            id: {
-                value: raw.id,
-                enumerable: false,
-            },
-            _raw: { value: raw, enumerable: false },
-        });
-
-        this.definePropertiesFromSchema();
+        return new Proxy(this, CoMapProxyHandler as ProxyHandler<this>);
+    }
 
-        if (this._encoding[indexSignature]) {
-            return new Proxy(this, CoMapProxyHandler<Fields>());
-        }
+    static create<M extends CoMap>(
+        this: SubclassedConstructor<M>,
+        init: Simplify<CoMapInit<M>>,
+        options: { owner: Account | Group }
+    ) {
+        return new this({ init, owner: options.owner });
     }
 
     toJSON() {
         const jsonedFields = this._raw.keys().map((key) => {
-            const tKey = key as OwnKeys<Fields>;
-            const descriptor = this._encoding[tKey] as FieldDescriptor;
+            const tKey = key as CoKeys<this>;
+            const descriptor = (this._schema[tKey] ||
+                this._schema[ItemsSym]) as Schema;
 
             if (descriptor == "json" || "encode" in descriptor) {
                 return [key, this._raw.get(key)];
-            } else if ("ref" in descriptor) {
+            } else if (isRefEncoded(descriptor)) {
                 const jsonedRef = (this as any)[tKey]?.toJSON();
                 return [key, jsonedRef];
             } else {
@@ -220,166 +184,98 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     }
 
     rawFromInit<Fields extends object = Record<string, any>>(
-        options: { owner: Account | Group } | { fromRaw: RawCoMap },
-        init: Simplify<CoMapInit<Fields>> | undefined
+        init: Simplify<CoMapInit<Fields>> | undefined,
+        owner: Account | Group
     ) {
-        let raw: RawCoMap;
+        const rawOwner = owner._raw;
 
-        if ("fromRaw" in options) {
-            raw = options.fromRaw;
-        } else {
-            const rawOwner = options.owner._raw;
-
-            const rawInit = {} as {
-                [key in keyof Fields]: JsonValue | undefined;
-            };
-
-            if (init)
-                for (const key of Object.keys(init) as (keyof Fields)[]) {
-                    const initValue = init[key as keyof typeof init];
-
-                    const descriptor = (this._encoding[
-                        key as keyof typeof this._encoding
-                    ] || this._encoding[indexSignature]) as FieldDescriptor;
-
-                    if (descriptor === "json") {
-                        rawInit[key] = initValue as JsonValue;
-                    } else if ("ref" in descriptor) {
-                        if (initValue) {
-                            rawInit[key] = (initValue as unknown as CoValue).id;
-                        }
-                    } else if ("encoded" in descriptor) {
-                        rawInit[key] = Schema.encodeSync(descriptor.encoded)(
-                            initValue as any
-                        );
-                    }
-                }
+        const rawInit = {} as {
+            [key in keyof Fields]: JsonValue | undefined;
+        };
 
-            raw = rawOwner.createMap(rawInit);
-        }
-        return raw;
-    }
+        if (init)
+            for (const key of Object.keys(init) as (keyof Fields)[]) {
+                const initValue = init[key as keyof typeof init];
 
-    static encoding<V extends CoMap>(
-        this: { new (...args: any): V } & typeof CoMap,
-        fields: Simplify<{
-            [Key in keyof V["_encoding"] as V["_encoding"][Key] extends never
-                ? never
-                : Key]: Simplify<V["_encoding"][Key]>;
-        }>
-    ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, fields);
-    }
+                const descriptor = (this._schema[
+                    key as keyof typeof this._schema
+                ] || this._schema[ItemsSym]) as Schema;
 
-    private definePropertiesFromSchema() {
-        for (const [key, fieldSchema] of Object.entries(this._encoding)) {
-            if (key === "indexSignature") continue;
-            const descriptor = fieldSchema as FieldDescriptor;
-            if (descriptor === "json") {
-                Object.defineProperty(
-                    this,
-                    key,
-                    this.primitivePropDef(key as string)
-                );
-            } else if ("encoded" in descriptor) {
-                Object.defineProperty(
-                    this,
-                    key,
-                    this.encodedPropDef(key as string, descriptor.encoded)
-                );
-            } else if ("ref" in descriptor) {
-                Object.defineProperty(
-                    this,
-                    key,
-                    this.refPropDef(
-                        key as string,
-                        (descriptor as RefField<CoValue>).ref
-                    )
-                );
+                if (descriptor === "json") {
+                    rawInit[key] = initValue as JsonValue;
+                } else if (isRefEncoded(descriptor)) {
+                    if (initValue) {
+                        rawInit[key] = (initValue as unknown as CoValue).id;
+                    }
+                } else if ("encoded" in descriptor) {
+                    rawInit[key] = encodeSync(descriptor.encoded)(
+                        initValue as any
+                    );
+                }
             }
-        }
-    }
 
-    private primitivePropDef(key: string): PropertyDescriptor {
-        return {
-            get: () => {
-                return this._raw.get(key);
-            },
-            set(this: CoMap, value: JsonValue) {
-                this._raw.set(key, value);
-            },
-            enumerable: true,
-            configurable: true,
-        };
+        return rawOwner.createMap(rawInit);
     }
 
-    private encodedPropDef(key: string, arg: Encoder<any>): PropertyDescriptor {
-        return {
-            get: () => {
-                const raw = this._raw.get(key);
-                return raw === undefined
-                    ? undefined
-                    : Schema.decodeSync(arg)(raw);
-            },
-            set(this: CoMap, value: unknown) {
-                this._raw.set(key, Schema.encodeSync(arg)(value));
-            },
-            enumerable: true,
-            configurable: true,
-        };
-    }
+    static Record<Value>(value: IfCo<Value, Value>) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+        class RecordLikeCoMap extends CoMap {
+            [ItemsSym] = value;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+        interface RecordLikeCoMap extends Record<string, Value> {}
 
-    private refPropDef(
-        key: string,
-        ref: () => CoValueClass<CoValue>
-    ): PropertyDescriptor {
-        return {
-            get: () => {
-                const rawID = this._raw.get(key);
-                return rawID === undefined
-                    ? undefined
-                    : new ValueRef(
-                          rawID as unknown as ID<CoValue>,
-                          this._loadedAs,
-                          ref()
-                      ).accessFrom(this);
-            },
-            set: (value: CoValue) => {
-                this._raw.set(key, value.id);
-                subscriptionsScopes.get(this)?.onRefAccessedOrSet(value.id);
-            },
-            enumerable: true,
-            configurable: true,
-        };
+        return RecordLikeCoMap;
     }
 }
 
-export type OwnKeys<Fields extends object> = Exclude<
+export type CoKeys<Fields extends object> = Exclude<
     keyof Fields & string,
-    keyof CoMap<Record<string, never>> | `_${string}`
+    keyof CoMap
 >;
 
 export type CoMapInit<Fields extends object> = {
-    [Key in OwnKeys<Fields> as undefined extends Fields[Key]
+    [Key in CoKeys<Fields> as undefined extends Fields[Key]
         ? never
         : null extends Fields[Key]
           ? never
-          : Key]: Fields[Key];
-} & { [Key in OwnKeys<Fields>]?: Fields[Key] };
+          : IfCo<Fields[Key], Key>]: Fields[Key];
+} & { [Key in CoKeys<Fields> as IfCo<Fields[Key], Key>]?: Fields[Key] };
+
+function tryInit(map: CoMap) {
+    if (
+        map[InitValues] &&
+        (map._schema[ItemsSym] ||
+            Object.keys(map[InitValues].init).every(
+                (key) => (map._schema as any)[key]
+            ))
+    ) {
+        const raw = map.rawFromInit(
+            map[InitValues].init,
+            map[InitValues].owner
+        );
+        Object.defineProperties(map, {
+            id: {
+                value: raw.id,
+                enumerable: false,
+            },
+            _raw: { value: raw, enumerable: false },
+        });
+        delete map[InitValues];
+    }
+}
 
 // TODO: cache handlers per descriptor for performance?
-function CoMapProxyHandler<Fields extends EnsureValid<Fields>>(): ProxyHandler<
-    CoMap<Fields>
-> {
-    return {
-        get(target, key, receiver) {
-            const descriptor = target._encoding[
-                indexSignature
-            ] as FieldDescriptor;
-            if (key in target || typeof key === "symbol") {
-                return Reflect.get(target, key, receiver);
-            } else {
+const CoMapProxyHandler: ProxyHandler<CoMap> = {
+    get(target, key, receiver) {
+        if (key === "_schema") {
+            return Reflect.get(target, key);
+        } else if (key in target) {
+            return Reflect.get(target, key, receiver);
+        } else {
+            const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
+                target._schema[ItemsSym]) as Schema;
+            if (descriptor && typeof key === "string") {
                 const raw = target._raw.get(key);
 
                 if (descriptor === "json") {
@@ -387,61 +283,103 @@ function CoMapProxyHandler<Fields extends EnsureValid<Fields>>(): ProxyHandler<
                 } else if ("encoded" in descriptor) {
                     return raw === undefined
                         ? undefined
-                        : Schema.decodeSync(descriptor.encoded)(raw);
-                } else if ("ref" in descriptor) {
+                        : decodeSync(descriptor.encoded)(raw);
+                } else if (isRefEncoded(descriptor)) {
                     return raw === undefined
                         ? undefined
-                        : new ValueRef(
+                        : new Ref(
                               raw as unknown as ID<CoValue>,
                               target._loadedAs,
-                              descriptor.ref()
-                          ).accessFrom(target);
+                              descriptor
+                          ).accessFrom(receiver);
                 }
-            }
-        },
-        set(target, key, value, receiver) {
-            const descriptor = target._encoding[
-                indexSignature
-            ] as FieldDescriptor;
-            if (key in target || typeof key === "symbol") {
-                return Reflect.set(target, key, value, receiver);
             } else {
-                if (descriptor === "json") {
-                    target._raw.set(key, value);
-                } else if ("encoded" in descriptor) {
-                    target._raw.set(
-                        key,
-                        Schema.encodeSync(descriptor.encoded)(value)
-                    );
-                } else if ("ref" in descriptor) {
-                    target._raw.set(key, value.id);
-                    subscriptionsScopes
-                        .get(target)
-                        ?.onRefAccessedOrSet(value.id);
-                }
-                return true;
+                return undefined;
             }
-        },
-        ownKeys(target) {
-            const keys = Reflect.ownKeys(target);
-            for (const key of target._raw.keys()) {
-                if (!keys.includes(key)) {
-                    keys.push(key);
-                }
+        }
+    },
+    set(target, key, value, receiver) {
+        if (
+            (typeof key === "string" || ItemsSym) &&
+            typeof value === "object" &&
+            SchemaInit in value
+        ) {
+            (target.constructor as typeof CoMap)._schema ||= {};
+            (target.constructor as typeof CoMap)._schema[key] =
+                value[SchemaInit];
+            tryInit(target);
+            return true;
+        }
+
+        const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
+            target._schema[ItemsSym]) as Schema;
+        if (descriptor && typeof key === "string") {
+            if (descriptor === "json") {
+                target._raw.set(key, value);
+            } else if ("encoded" in descriptor) {
+                target._raw.set(key, encodeSync(descriptor.encoded)(value));
+            } else if (isRefEncoded(descriptor)) {
+                target._raw.set(key, value.id);
+                subscriptionsScopes.get(target)?.onRefAccessedOrSet(value.id);
+            }
+            return true;
+        } else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    },
+    defineProperty(target, key, attributes) {
+        if (
+            "value" in attributes &&
+            typeof attributes.value === "object" &&
+            SchemaInit in attributes.value
+        ) {
+            (target.constructor as typeof CoMap)._schema ||= {};
+            (target.constructor as typeof CoMap)._schema[key as string] =
+                attributes.value[SchemaInit];
+            tryInit(target);
+            return true;
+        } else {
+            return Reflect.defineProperty(target, key, attributes);
+        }
+    },
+    ownKeys(target) {
+        const keys = Reflect.ownKeys(target).filter((k) => k !== ItemsSym);
+        // for (const key of Reflect.ownKeys(target._schema)) {
+        //     if (key !== ItemsSym && !keys.includes(key)) {
+        //         keys.push(key);
+        //     }
+        // }
+        for (const key of target._raw.keys()) {
+            if (!keys.includes(key)) {
+                keys.push(key);
             }
+        }
 
-            return keys;
-        },
-        getOwnPropertyDescriptor(target, key) {
-            if (key in target) {
-                return Reflect.getOwnPropertyDescriptor(target, key);
-            } else if (key in target._raw.ops) {
+        return keys;
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (key in target) {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        } else {
+            const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
+                target._schema[ItemsSym]) as Schema;
+            if (descriptor || key in target._raw.ops) {
                 return {
                     enumerable: true,
                     configurable: true,
                     writable: true,
                 };
             }
-        },
-    };
-}
+        }
+    },
+    deleteProperty(target, key) {
+        const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
+            target._schema[ItemsSym]) as Schema;
+        if (typeof key === "string" && descriptor) {
+            target._raw.delete(key);
+            return true;
+        } else {
+            return Reflect.deleteProperty(target, key);
+        }
+    },
+};