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

package/src/coValues/coMap.ts

@@ -1,44 +1,41 @@
 import type { JsonValue, RawCoMap } from "cojson";
 import type { Simplify } from "effect/Types";
-import { Schema } from "@effect/schema";
+import { Schema as EffectSchema } from "@effect/schema";
 import type {
     CoValue,
-    Encoder,
-    FieldDescriptor,
-    FieldDescriptorFor,
+    Schema,
+    SchemaFor,
     Group,
     ID,
-    RefField,
+    RefEncoded,
     EnsureCoValueNullable,
-    CoValueClass,
+    IfCo,
 } 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
+type ValidFields<Fields extends { [key: string]: any; [ItemsSym]?: any }> = {
+    [Key in keyof Fields & string as IfCo<
+        Fields[Key],
+        IfOptionalKey<Key, Fields>
     >]?: EnsureCoValueNullable<Fields[Key], Key>;
 } & {
-    [Key in OwnKeys<Fields> as IfRequiredKey<
-        Key,
-        Fields
+    [Key in keyof Fields & string as IfCo<
+        Fields[Key],
+        IfRequiredKey<Key, Fields>
     >]: EnsureCoValueNullable<Fields[Key], Key>;
 } & {
-    [Key in indexSignature]?: EnsureCoValueNullable<
-        Fields[indexSignature],
-        Key
-    >;
+    [Key in ItemsSym]?: EnsureCoValueNullable<Fields[ItemsSym], Key>;
 };
 
 type IfOptionalKey<Key extends keyof Obj, Obj> = Pick<
@@ -56,36 +53,53 @@ type IfRequiredKey<Key extends keyof Obj, Obj> = Pick<
 
 type DefaultFields = {
     [key: string]: any;
-    [indexSignature]?: any;
+    [ItemsSym]?: any;
+};
+
+type CoMapSchema<Fields extends object> = {
+    [Key in OwnKeys<Fields> as IfCo<Fields[Key], Key>]: SchemaFor<
+        Fields[Key]
+    >;
+} & {
+    [ItemsSym]: ItemsSym extends keyof Fields
+        ? SchemaFor<Fields[ItemsSym]>
+        : never;
+};
+
+type CoMapEdit<V> = {
+    value?: V;
+    ref?: V extends CoValue ? Ref<V> : never;
+    by?: Account;
+    madeAt: Date;
 };
 
-export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
+type InitValuesFor<C extends CoMap> = {
+    init: Simplify<CoMapInit<C>>;
+    owner: Account | Group;
+};
+
+export class CoMap<Fields extends ValidFields<Fields> = DefaultFields>
     extends CoValueBase
     implements CoValue<"CoMap", RawCoMap>
 {
-    id!: ID<this>;
-    _type!: "CoMap";
+    declare id: ID<this>;
+    declare _type: "CoMap";
     static {
         this.prototype._type = "CoMap";
     }
-    _raw!: RawCoMap;
+    declare _raw: RawCoMap;
 
     static _schema: any;
-    get _schema(): {
-        [Key in OwnKeys<Fields>]: FieldDescriptorFor<Fields[Key]>;
-    } & {
-        [indexSignature]: indexSignature extends keyof Fields
-            ? FieldDescriptorFor<Fields[indexSignature]>
-            : never;
-    } {
-        return (this.constructor as typeof CoMap)._schema;
+    get _schema() {
+        return (this.constructor as typeof CoMap)
+            ._schema as CoMapSchema<this>;
     }
 
     get _refs(): {
-        [Key in OwnKeys<Fields> as NonNullable<Fields[Key]> extends CoValue
+        [Key in OwnKeys<this> as NonNullable<this[Key]> extends CoValue
             ? Key
-            : never]: NonNullable<Fields[Key]> extends CoValue
-            ? ValueRef<NonNullable<Fields[Key]>>
+            : never]: NonNullable<this[Key]> extends CoValue
+            ? Ref<NonNullable<this[Key]>>
             : never;
     } {
         return makeRefs<OwnKeys<Fields>>(
@@ -94,22 +108,15 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
                 Object.keys(this._schema).filter((key) => {
                     const schema = this._schema[
                         key as keyof typeof this._schema
-                    ] as FieldDescriptor;
-                    schema !== "json" && "ref" in schema;
+                    ] as Schema;
+                    schema !== "json" && isRefEncoded(schema);
                 }) as OwnKeys<Fields>[],
             this._loadedAs,
-            (key) => (this._schema[key] as RefField<CoValue>).ref()
+            (key) => this._schema[key] 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);
@@ -117,32 +124,32 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
 
                 const descriptor = target._schema[
                     key as keyof typeof target._schema
-                ] as FieldDescriptor;
+                ] as Schema;
 
                 return {
                     value:
                         descriptor === "json"
                             ? rawEdit.value
                             : "encoded" in descriptor
-                              ? Schema.decodeSync(descriptor.encoded)(
+                              ? EffectSchema.decodeSync(descriptor.encoded)(
                                     rawEdit.value
                                 )
-                              : new ValueRef(
+                              : 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,13 +157,19 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
                     madeAt: rawEdit.at,
                 };
             },
-        }) as any;
+        }) as {
+            [Key in OwnKeys<this> as IfCo<this[Key], Key>]: CoMapEdit<
+                this[Key]
+            >;
+        };
     }
 
     get _loadedAs() {
         return Account.fromNode(this._raw.core.node);
     }
 
+    [InitValues]?: InitValuesFor<this>;
+
     constructor(_init: undefined, options: { fromRaw: RawCoMap });
     constructor(
         init: Simplify<CoMapInit<Fields>>,
@@ -168,39 +181,34 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     ) {
         super();
 
-        if (!this._schema) {
-            throw new Error(
-                "No schema found in " +
-                    this.constructor.name +
-                    " - ensure that you have a `static { this.define({...}) }` block in the class definition."
-            );
+        if (init && "owner" in options) {
+            this[InitValues] = {
+                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();
-
-        if (this._schema[indexSignature]) {
-            return new Proxy(this, CoMapProxyHandler<Fields>());
-        }
+        return new Proxy(this, CoMapProxyHandler as ProxyHandler<this>);
     }
 
     toJSON() {
         const jsonedFields = this._raw.keys().map((key) => {
             const tKey = key as OwnKeys<Fields>;
-            const descriptor = this._schema[tKey] as FieldDescriptor;
+            const descriptor = this._schema[tKey] 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,144 +228,43 @@ 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;
+        };
 
-            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];
 
-            if (init)
-                for (const key of Object.keys(init) as (keyof Fields)[]) {
-                    const initValue = init[key as keyof typeof init];
+                const descriptor = (this._schema[
+                    key as keyof typeof this._schema
+                ] || this._schema[ItemsSym]) as Schema;
 
-                    const descriptor = (this._schema[
-                        key as keyof typeof this._schema
-                    ] || this._schema[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
-                        );
+                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] = EffectSchema.encodeSync(descriptor.encoded)(
+                        initValue as any
+                    );
                 }
-
-            raw = rawOwner.createMap(rawInit);
-        }
-        return raw;
-    }
-
-    static encoding<V extends CoMap>(
-        this: { new (...args: any): V } & typeof CoMap,
-        fields: Simplify<{
-            [Key in keyof V["_schema"] as V["_schema"][Key] extends never
-                ? never
-                : Key]: Simplify<V["_schema"][Key]>;
-        }>
-    ) {
-        this._schema ||= {};
-        Object.assign(this._schema, fields);
-    }
-
-    private definePropertiesFromSchema() {
-        for (const [key, fieldSchema] of Object.entries(this._schema)) {
-            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
-                    )
-                );
             }
-        }
-    }
-
-    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,
-        };
-    }
 
-    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,
-        };
-    }
-
-    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 rawOwner.createMap(rawInit);
     }
 }
 
 export type OwnKeys<Fields extends object> = Exclude<
     keyof Fields & string,
-    keyof CoMap<Record<string, never>> | `_${string}`
+    keyof CoMap<Record<string, never>>
 >;
 
 export type CoMapInit<Fields extends object> = {
@@ -365,21 +272,44 @@ export type CoMapInit<Fields extends object> = {
         ? never
         : null extends Fields[Key]
           ? never
-          : Key]: Fields[Key];
-} & { [Key in OwnKeys<Fields>]?: Fields[Key] };
+          : IfCo<Fields[Key], Key>]: Fields[Key];
+} & { [Key in OwnKeys<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._schema[
-                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 +317,97 @@ 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) {
+                        : EffectSchema.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._schema[
-                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,
+                    EffectSchema.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,
                 };
             }
-        },
-    };
-}
+        }
+    },
+};