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

package/src/coValues/coStream.ts

@@ -17,24 +17,40 @@ import type {
     Group,
     ID,
     Me,
+    IsVal,
+} from "../internal.js";
+import {
+    ItemsSym,
+    Account,
+    CoValueBase,
+    Ref,
+    inspect,
+    val,
+    InitValues,
+    SchemaInit,
 } from "../internal.js";
-import { Account, CoValueBase, Ref, inspect } from "../internal.js";
 import { Schema } from "@effect/schema";
 
 export type CoStreamEntry<Item> = {
     value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
-    ref?: NonNullable<Item> extends CoValue
-        ? Ref<NonNullable<Item>>
-        : never;
+    ref?: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
     by?: Account;
     madeAt: Date;
     tx: CojsonInternalTypes.TransactionID;
 };
 
-export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
+export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
     extends CoValueBase
     implements CoValue<"CoStream", RawCoStream>
 {
+    static Of<Item extends ValidItem<Item, "CoStream"> = any>(
+        item: IsVal<Item, Item>
+    ): typeof CoStream<Item> {
+        return class CoStreamOf extends CoStream<Item> {
+            [val.items] = item;
+        };
+    }
+
     id!: ID<this>;
     _type!: "CoStream";
     static {
@@ -43,27 +59,31 @@ export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
     _raw!: RawCoStream;
 
     /** @internal This is only a marker type and doesn't exist at runtime */
-    _item!: Item;
+    [ItemsSym]!: Item;
     static _encoding: any;
     get _encoding(): {
-        _item: EncodingFor<Item>;
+        [ItemsSym]: EncodingFor<Item>;
     } {
         return (this.constructor as typeof CoStream)._encoding;
     }
 
-    by: {
-        [key: ID<Account>]: CoStreamEntry<Item>;
-    } = {};
+    [key: ID<Account>]: CoStreamEntry<Item>;
+
     get byMe(): CoStreamEntry<Item> | undefined {
-        return this.by[this._loadedAs.id];
+        return this[this._loadedAs.id];
     }
-    in: {
+    perSession!: {
         [key: SessionID]: CoStreamEntry<Item>;
-    } = {};
+    };
     get inCurrentSession(): CoStreamEntry<Item> | undefined {
-        return this.in[this._loadedAs.sessionID];
+        return this.perSession[this._loadedAs.sessionID];
     }
 
+    [InitValues]?: {
+        init?: Item[];
+        owner: Account | Group;
+    };
+
     constructor(_init: undefined, options: { fromRaw: RawCoStream });
     constructor(init: Item[], options: { owner: Account | Group });
     constructor(
@@ -72,90 +92,32 @@ export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
     ) {
         super();
 
-        let raw: RawCoStream;
-
         if ("fromRaw" in options) {
-            raw = options.fromRaw;
-        } else {
-            const rawOwner = options.owner._raw;
-
-            raw = rawOwner.createStream();
-        }
-
-        Object.defineProperties(this, {
-            id: {
-                value: raw.id,
-                enumerable: false,
-            },
-            _raw: { value: raw, enumerable: false },
-        });
-
-        if (init !== undefined) {
-            for (const item of init) {
-                this.pushItem(item);
-            }
-        }
-
-        this.updateEntries();
-    }
-
-    private updateEntries() {
-        for (const accountID of this._raw.accounts()) {
-            Object.defineProperty(this.by, accountID, {
-                get: () => {
-                    const rawEntry = this._raw.lastItemBy(accountID);
-
-                    if (!rawEntry) return;
-                    return entryFromRawEntry(
-                        this,
-                        rawEntry,
-                        this._loadedAs,
-                        accountID as unknown as ID<Account>,
-                        this._encoding._item
-                    );
+            Object.defineProperties(this, {
+                id: {
+                    value: options.fromRaw.id,
+                    enumerable: false,
                 },
-                configurable: true,
-                enumerable: true,
+                _raw: { value: options.fromRaw, enumerable: false },
             });
+        } else {
+            this[InitValues] = {
+                init,
+                owner: options.owner,
+            };
         }
 
-        for (const sessionID of this._raw.sessions()) {
-            Object.defineProperty(this.in, sessionID, {
-                get: () => {
-                    const rawEntry = this._raw.lastItemIn(
-                        sessionID as unknown as SessionID
-                    );
-
-                    if (!rawEntry) return;
-                    const by =
-                        cojsonInternals.accountOrAgentIDfromSessionID(
-                            sessionID
-                        );
-                    return entryFromRawEntry(
-                        this,
-                        rawEntry,
-                        this._loadedAs,
-                        cojsonInternals.isAccountID(by)
-                            ? (by as unknown as ID<Account>)
-                            : undefined,
-                        this._encoding._item
-                    );
-                },
-                configurable: true,
-                enumerable: true,
-            });
-        }
+        return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
     }
 
     push(...items: Item[]) {
         for (const item of items) {
             this.pushItem(item);
         }
-        this.updateEntries();
     }
 
     private pushItem(item: Item) {
-        const itemDescriptor = this._encoding._item as Encoding;
+        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
 
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
@@ -167,7 +129,7 @@ export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding._item as Encoding;
+        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
         const mapper =
             itemDescriptor === "json"
                 ? (v: unknown) => v
@@ -178,14 +140,14 @@ export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
         return {
             id: this.id,
             _type: this._type,
-            by: Object.fromEntries(
-                Object.entries(this.by).map(([account, entry]) => [
+            ...Object.fromEntries(
+                Object.entries(this).map(([account, entry]) => [
                     account,
                     mapper(entry.value),
                 ])
             ),
             in: Object.fromEntries(
-                Object.entries(this.in).map(([session, entry]) => [
+                Object.entries(this.perSession).map(([session, entry]) => [
                     session,
                     mapper(entry.value),
                 ])
@@ -199,7 +161,7 @@ export class CoStream<Item extends ValidItem<Item, "Co.Stream"> = any>
 
     static encoding<V extends CoStream>(
         this: { new (...args: any): V } & typeof CoStream,
-        def: { _item: V["_encoding"]["_item"] }
+        def: { [ItemsSym]: V["_encoding"][ItemsSym] }
     ) {
         this._encoding ||= {};
         Object.assign(this._encoding, def);
@@ -234,7 +196,7 @@ function entryFromRawEntry<Item>(
                 return new Ref(
                     rawId as unknown as ID<CoValue>,
                     loadedAs,
-                    itemField.ref()
+                    itemField
                 );
             }
         },
@@ -244,7 +206,7 @@ function entryFromRawEntry<Item>(
                 new Ref(
                     accountID as unknown as ID<Account>,
                     loadedAs,
-                    Account
+                    {ref: () => Account}
                 )?.accessFrom(accessFrom)
             );
         },
@@ -253,6 +215,122 @@ function entryFromRawEntry<Item>(
     };
 }
 
+function init(stream: CoStream) {
+    const init = stream[InitValues];
+    if (!init) return;
+
+    const raw = init.owner._raw.createStream();
+
+    Object.defineProperties(stream, {
+        id: {
+            value: raw.id,
+            enumerable: false,
+        },
+        _raw: { value: raw, enumerable: false },
+    });
+
+    if (init.init) {
+        stream.push(...init.init);
+    }
+
+    delete stream[InitValues];
+}
+
+export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
+    get(target, key, receiver) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            const rawEntry = target._raw.lastItemBy(key as AccountID);
+
+            if (!rawEntry) return;
+            return entryFromRawEntry(
+                receiver,
+                rawEntry,
+                target._loadedAs,
+                key as unknown as ID<Account>,
+                target._encoding[ItemsSym]
+            );
+        } else if (key === "perSession") {
+            return new Proxy(receiver, CoStreamPerSessionProxyHandler);
+        } else {
+            return Reflect.get(target, key, receiver);
+        }
+    },
+    set(target, key, value, receiver) {
+        if (
+            key === ItemsSym &&
+            typeof value === "object" &&
+            SchemaInit in value
+        ) {
+            (target.constructor as typeof CoStream)._encoding ||= {};
+            (target.constructor as typeof CoStream)._encoding[ItemsSym] =
+                value[SchemaInit];
+            init(target);
+            return true;
+        } else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    },
+    defineProperty(target, key, descriptor) {
+        if (
+            descriptor.value &&
+            key === ItemsSym &&
+            typeof descriptor.value === "object" &&
+            SchemaInit in descriptor.value
+        ) {
+            (target.constructor as typeof CoStream)._encoding ||= {};
+            (target.constructor as typeof CoStream)._encoding[ItemsSym] =
+                descriptor.value[SchemaInit];
+            init(target);
+            return true;
+        } else {
+            return Reflect.defineProperty(target, key, descriptor);
+        }
+    },
+    ownKeys(target) {
+        const keys = Reflect.ownKeys(target);
+
+        for (const accountID of target._raw.accounts()) {
+            keys.push(accountID);
+        }
+
+        return keys;
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: false,
+            };
+        } else {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        }
+    },
+};
+
+const CoStreamPerSessionProxyHandler: ProxyHandler<CoStream> = {
+    get(target, key, receiver) {
+        if (typeof key === "string" && key.includes("session")) {
+            const sessionID = key as SessionID;
+            const rawEntry = target._raw.lastItemIn(sessionID);
+
+            if (!rawEntry) return;
+            const by = cojsonInternals.accountOrAgentIDfromSessionID(sessionID);
+            return entryFromRawEntry(
+                target,
+                rawEntry,
+                target._loadedAs,
+                cojsonInternals.isAccountID(by)
+                    ? (by as unknown as ID<Account>)
+                    : undefined,
+                target._encoding[ItemsSym]
+            );
+        } else {
+            return Reflect.get(target, key, receiver);
+        }
+    },
+};
+
 export class BinaryCoStream
     extends CoValueBase
     implements CoValue<"BinaryCoStream", RawBinaryCoStream>

package/src/coValues/extensions/imageDef.ts

@@ -1,17 +1,18 @@
 import {
     BinaryCoStream,
     CoMap,
+    val,
     subscriptionsScopes,
 } from "../../internal.js";
 
 export class ImageDefinition extends CoMap<ImageDefinition> {
-    declare originalSize: [number, number];
-    declare placeholderDataURL?: string;
+    originalSize = val.json<[number, number]>();
+    placeholderDataURL? = val.string;
 
-    [res: `${number}x${number}`]: BinaryCoStream | null;
-    declare _item: BinaryCoStream | null;
+    [val.items] = val.ref(() => BinaryCoStream);
+    [res: `${number}x${number}`]: val<BinaryCoStream | null>;
 
-    get _highestResAvailable():
+    get highestResAvailable():
         | { res: `${number}x${number}`; stream: BinaryCoStream }
         | undefined {
         if (!subscriptionsScopes.get(this)) {
@@ -51,9 +52,4 @@ export class ImageDefinition extends CoMap<ImageDefinition> {
             }
         );
     }
-}
-ImageDefinition.encoding({
-    originalSize: "json",
-    placeholderDataURL: "json",
-    _item: { ref: () => BinaryCoStream },
-});
+}

package/src/coValues/group.ts

@@ -1,23 +1,18 @@
-import type { CoID, Everyone, RawCoMap, RawGroup, Role } from "cojson";
-import type {
-    CoValue,
-    CoValueClass,
-    ID,
-    JsonEncoded,
-    RefEncoded,
-} from "../internal.js";
+import type { Everyone, RawGroup, Role } from "cojson";
+import type { CoValue, ID, JsonEncoded, RefEncoded } from "../internal.js";
 import {
     Account,
     CoMap,
     CoValueBase,
     Ref,
+    val,
     isControlledAccount,
+    AccountAndGroupProxyHandler,
 } from "../internal.js";
 
-export class Profile extends CoMap<{ name: string }> {
-    declare name: string;
+export class Profile extends CoMap<{ name: val<string> }> {
+    name = val.string;
 }
-Profile.encoding({ name: "json" });
 
 export class Group<
         Def extends { profile: Profile | null; root: CoMap | null } = {
@@ -63,9 +58,7 @@ export class Group<
     root!: Def["root"] extends CoMap ? Def["root"] | null : undefined;
 
     get _refs(): {
-        profile: Def["profile"] extends Profile
-            ? Ref<Def["profile"]>
-            : never;
+        profile: Def["profile"] extends Profile ? Ref<Def["profile"]> : never;
         root: Def["root"] extends CoMap ? Ref<Def["root"]> : never;
     } {
         const profileID = this._raw.get("profile") as unknown as
@@ -80,22 +73,16 @@ export class Group<
                 (new Ref(
                     profileID,
                     this._loadedAs,
-                    (
-                        this._encoding.profile as RefEncoded<
-                            NonNullable<Def["profile"]>
-                        >
-                    ).ref()
+                    this._encoding.profile as RefEncoded<
+                        NonNullable<Def["profile"]>
+                    >
                 ) as any),
             root:
                 rootID &&
                 (new Ref(
                     rootID,
                     this._loadedAs,
-                    (
-                        this._encoding.root as RefEncoded<
-                            NonNullable<Def["root"]>
-                        >
-                    ).ref()
+                    this._encoding.root as RefEncoded<NonNullable<Def["root"]>>
                 ) as any),
         };
     }
@@ -134,35 +121,12 @@ export class Group<
                 enumerable: false,
             },
             _raw: { value: raw, enumerable: false },
-            profile: {
-                get: () => {
-                    const ref = this._refs.profile;
-                    return ref ? ref.accessFrom(this) : (undefined as any);
-                },
-                set: (value: Def["profile"] | null) => {
-                    if (value) {
-                        this._raw.set(
-                            "profile",
-                            value.id as unknown as CoID<RawCoMap>
-                        );
-                    }
-                },
-            },
-            root: {
-                get: () => {
-                    const ref = this._refs.root;
-                    return ref ? ref.accessFrom(this) : (undefined as any);
-                },
-                set: (value: Def["root"] | null) => {
-                    if (value) {
-                        this._raw.set(
-                            "root",
-                            value.id as unknown as CoID<RawCoMap>
-                        );
-                    }
-                },
-            },
         });
+
+        return new Proxy(
+            this,
+            AccountAndGroupProxyHandler as ProxyHandler<this>
+        );
     }
 
     myRole(): Role | undefined {
@@ -172,15 +136,4 @@ export class Group<
     addMember(member: Everyone | Account, role: Role) {
         this._raw.addMember(member === "everyone" ? member : member._raw, role);
     }
-
-    static define<V extends Account>(
-        this: CoValueClass<V> & typeof Account,
-        fields: {
-            profile: V["_encoding"]["profile"];
-            root: V["_encoding"]["root"];
-        }
-    ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, fields);
-    }
 }

package/src/coValues/interfaces.ts

@@ -15,10 +15,7 @@ export type SubclassedConstructor<T> = {
     new (...args: any[]): T;
 };
 
-export interface CoValueClass<
-    Value extends CoValue = CoValue,
-    Init = any,
-> {
+export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
     /** @category Construction and loading */
     new (init: Init, options: { owner: Account | Group }): Value;
 
@@ -117,7 +114,11 @@ export class CoValueBase implements CoValue {
     ): Effect.Effect<V, UnavailableError, AccountCtx> {
         return Effect.gen(this, function* (_) {
             const account = yield* _(AccountCtx);
-            return yield* _(new Ref(id as ID<V>, account, this).loadEf());
+            return yield* _(
+                new Ref(id as ID<V>, account, {
+                    ref: () => this as CoValueClass<V>,
+                }).loadEf()
+            );
         });
     }
 
@@ -129,9 +130,9 @@ export class CoValueBase implements CoValue {
             onProgress?: (progress: number) => void;
         }
     ): Promise<V | undefined> {
-        return new Ref(id as ID<V>, options.as, this).load(
-            options?.onProgress && { onProgress: options.onProgress }
-        );
+        return new Ref(id as ID<V>, options.as, {
+            ref: () => this as CoValueClass<V>,
+        }).load(options?.onProgress && { onProgress: options.onProgress });
     }
 
     static subscribe<V extends CoValue, Acc extends Account>(

package/src/implementation/encoding.ts

@@ -1,17 +1,54 @@
-import type { JsonValue } from "cojson";
+import type { JsonValue, RawCoValue } from "cojson";
 import type { CoValue, CoValueClass } from "../internal.js";
 import type { Schema, TypeId } from "@effect/schema/Schema";
 
+export type ValMarker = { readonly __field: unique symbol };
+export type val<T> = T | (T & ValMarker);
+export type IsVal<C, R> = C extends infer _A | infer B
+    ? B extends ValMarker
+        ? 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 val = {
+    string: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<string>,
+    number: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<number>,
+    boolean: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<boolean>,
+    literal: <T extends string | number | boolean>(
+        _lit: T
+    ): val<T> => {
+        return {[SchemaInit]: "json" satisfies Encoding } as any;
+    },
+    json: <T extends JsonValue>(): val<T> => {
+        return {[SchemaInit]: "json" satisfies Encoding } as any;
+    },
+    encoded: <T>(arg: Encoder<T>): val<T> => {
+        return { [SchemaInit]: { encoded: arg } satisfies Encoding } as any;
+    },
+    ref: <C extends CoValueClass>(
+        arg: (_raw: InstanceType<C>['_raw']) => C
+    ): val<InstanceType<C> | null> => {
+        return { [SchemaInit]: { ref: arg } satisfies Encoding } as any;
+    },
+    items: ItemsSym as ItemsSym,
+}
+
 export type JsonEncoded = "json";
 export type EncodedAs<V> = { encoded: Encoder<V> };
 export type RefEncoded<V extends CoValue> = {
-    ref: () => CoValueClass<V>;
+    ref: (raw: RawCoValue) => CoValueClass<V>;
 };
 
-export type Encoding =
-    | JsonEncoded
-    | RefEncoded<CoValue>
-    | EncodedAs<any>;
+export type Encoding = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
 
 export type EncodingFor<Field> = NonNullable<Field> extends CoValue
     ? RefEncoded<NonNullable<Field>>
@@ -40,7 +77,7 @@ export const Encoders = {
 
 export type EnsureCoValueNullable<
     V,
-    Key extends string,
+    Key extends string | ItemsSym,
 > = NonNullable<V> extends CoValue
     ? null extends V
         ? V
@@ -55,12 +92,14 @@ export type EnsureCoValueNullable<
             ]
     : V;
 
-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;
+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;