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

package/src/coValues/group.ts

@@ -1,119 +1,97 @@
-import type { CoID, Everyone, RawCoMap, RawGroup, Role } from "cojson";
+import type { AccountID, Everyone, RawGroup, Role } from "cojson";
 import type {
     CoValue,
-    CoValueClass,
     ID,
-    PrimitiveField,
-    RefField,
+    RefEncoded,
+    Schema,
+    SubclassedConstructor,
 } from "../internal.js";
 import {
     Account,
     CoMap,
     CoValueBase,
-    ValueRef,
+    Ref,
+    co,
     isControlledAccount,
+    AccountAndGroupProxyHandler,
+    MembersSym,
 } from "../internal.js";
 
-export class Profile extends CoMap<{ name: string }> {
-    declare name: string;
+export class Profile extends CoMap {
+    name = co.string;
 }
-Profile.encoding({ name: "json" });
 
-export class Group<
-        Def extends { profile: Profile | null; root: CoMap | null } = {
-            profile: Profile | null;
-            root: CoMap | null;
-        },
-    >
-    extends CoValueBase
-    implements CoValue<"Group", RawGroup>
-{
-    id!: ID<this>;
-    _type!: "Group";
+export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
+    declare id: ID<this>;
+    declare _type: "Group";
     static {
         this.prototype._type = "Group";
     }
-    _raw!: RawGroup;
+    declare _raw: RawGroup;
 
-    static _encoding: any;
-    get _encoding(): {
-        profile: Def["profile"] extends CoValue
-            ? RefField<Def["profile"]>
-            : PrimitiveField;
-        root: Def["root"] extends CoValue
-            ? RefField<Def["root"]>
-            : PrimitiveField;
+    static _schema: any;
+    get _schema(): {
+        profile: Schema;
+        root: Schema;
+        [MembersSym]: RefEncoded<Account>;
     } {
-        return (this.constructor as typeof Group)._encoding;
+        return (this.constructor as typeof Group)._schema;
     }
     static {
-        this._encoding = {
-            profile: { json: true },
-            root: { json: true },
+        this._schema = {
+            profile: "json" satisfies Schema,
+            root: "json" satisfies Schema,
+            [MembersSym]: () => Account satisfies Schema,
         } as any;
-        Object.defineProperty(this.prototype, "_encoding", {
-            get: () => this._encoding,
+        Object.defineProperty(this.prototype, "_schema", {
+            get: () => this._schema,
         });
     }
 
-    profile!: Def["profile"] extends Profile
-        ? Def["profile"] | null
-        : undefined;
+    declare profile: Profile | null;
+    declare root: CoMap | null;
+    declare [MembersSym]: Account | null;
 
-    root!: Def["root"] extends CoMap ? Def["root"] | null : undefined;
-
-    get _refs(): {
-        profile: Def["profile"] extends Profile
-            ? ValueRef<Def["profile"]>
-            : never;
-        root: Def["root"] extends CoMap ? ValueRef<Def["root"]> : never;
-    } {
+    get _refs() {
         const profileID = this._raw.get("profile") as unknown as
-            | ID<NonNullable<Def["profile"]>>
+            | ID<NonNullable<this["profile"]>>
             | undefined;
         const rootID = this._raw.get("root") as unknown as
-            | ID<NonNullable<Def["root"]>>
+            | ID<NonNullable<this["root"]>>
             | undefined;
         return {
             profile:
                 profileID &&
-                (new ValueRef(
+                (new Ref(
                     profileID,
                     this._loadedAs,
-                    (
-                        this._encoding.profile as RefField<
-                            NonNullable<Def["profile"]>
-                        >
-                    ).ref()
-                ) as any),
+                    this._schema.profile as RefEncoded<
+                        NonNullable<this["profile"]>
+                    >
+                ) as any as this["profile"] extends Profile
+                    ? Ref<this["profile"]>
+                    : never),
             root:
                 rootID &&
-                (new ValueRef(
+                (new Ref(
                     rootID,
                     this._loadedAs,
-                    (
-                        this._encoding.root as RefField<
-                            NonNullable<Def["root"]>
-                        >
-                    ).ref()
-                ) as any),
+                    this._schema.root as RefEncoded<NonNullable<this["root"]>>
+                ) as any as this["root"] extends CoMap
+                    ? Ref<this["root"]>
+                    : never),
         };
     }
 
-    constructor(options: { owner: Account | Group });
-    constructor(init: any, options: { fromRaw: RawGroup });
-    constructor(init: undefined, options: { owner: Account | Group });
-    constructor(
-        init: undefined | { owner: Account | Group },
-        options?: { fromRaw: RawGroup } | { owner: Account | Group }
-    ) {
+    /** @deprecated Don't use constructor directly, use .create */
+    constructor(options: { fromRaw: RawGroup } | { owner: Account | Group }) {
         super();
         let raw: RawGroup;
 
         if (options && "fromRaw" in options) {
             raw = options.fromRaw;
         } else {
-            const initOwner = options?.owner || init?.owner;
+            const initOwner = options.owner;
             if (!initOwner) throw new Error("No owner provided");
             if (
                 initOwner instanceof Account &&
@@ -134,35 +112,19 @@ 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>
+        );
+    }
+
+    static create<G extends Group>(
+        this: SubclassedConstructor<G>,
+        options: { owner: Account }
+    ) {
+        return new this(options);
     }
 
     myRole(): Role | undefined {
@@ -171,16 +133,38 @@ export class Group<
 
     addMember(member: Everyone | Account, role: Role) {
         this._raw.addMember(member === "everyone" ? member : member._raw, role);
+        return this;
     }
 
-    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);
+    get members() {
+        return this._raw
+            .keys()
+            .filter((key) => {
+                return key === "everyone" || key.startsWith("co_");
+            })
+            .map((id) => {
+                const role = this._raw.get(id as Everyone | AccountID);
+                const accountID =
+                    id === "everyone"
+                        ? undefined
+                        : (id as unknown as ID<Account>);
+                const ref =
+                    accountID &&
+                    new Ref<NonNullable<this[MembersSym]>>(
+                        accountID,
+                        this._loadedAs,
+                        this._schema[MembersSym]
+                    );
+                const accessRef = () => ref?.accessFrom(this);
+
+                return {
+                    id: id as unknown as Everyone | ID<this[MembersSym]>,
+                    role,
+                    ref,
+                    get account() {
+                        return accessRef();
+                    },
+                };
+            });
     }
 }

package/src/coValues/interfaces.ts

@@ -7,18 +7,16 @@ import {
     AccountCtx,
     Group,
     SubscriptionScope,
-    ValueRef,
+    Ref,
     inspect,
+    subscriptionsScopes,
 } from "../internal.js";
 
 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;
 
@@ -81,11 +79,14 @@ export interface CoValue<Type extends string = string, Raw = any> {
 export function isCoValue(value: any): value is CoValue {
     return value && value._type !== undefined;
 }
+export function isCoValueClass(value: any): value is CoValueClass {
+    return typeof value === "function" && value.fromRaw !== undefined;
+}
 
 /** @category Schemas & CoValues - Abstract interfaces */
-export type ID<T> = CojsonInternalTypes.RawCoID & {
-    readonly __type: T;
-};
+export type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>;
+
+type IDMarker<out T> = { __type(_: never): T };
 
 export class CoValueBase implements CoValue {
     id!: ID<this>;
@@ -93,11 +94,20 @@ export class CoValueBase implements CoValue {
     _raw!: RawCoValue;
 
     get _owner(): Account | Group {
-        return this._raw.group instanceof RawAccount
+        const owner = this._raw.group instanceof RawAccount
             ? Account.fromRaw(this._raw.group)
             : Group.fromRaw(this._raw.group);
+
+        const subScope = subscriptionsScopes.get(this);
+        if (subScope) {
+            subScope.onRefAccessedOrSet(owner.id);
+            subscriptionsScopes.set(owner, subScope);
+        }
+
+        return owner;
     }
 
+    /** @private */
     get _loadedAs() {
         return Account.fromNode(this._raw.core.node);
     }
@@ -108,7 +118,7 @@ export class CoValueBase implements CoValue {
         this: SubclassedConstructor<V>,
         raw: RawCoValue
     ): V {
-        return new this(undefined, { fromRaw: raw });
+        return new this({ fromRaw: raw });
     }
 
     static loadEf<V extends CoValue>(
@@ -117,7 +127,9 @@ export class CoValueBase implements CoValue {
     ): Effect.Effect<V, UnavailableError, AccountCtx> {
         return Effect.gen(this, function* (_) {
             const account = yield* _(AccountCtx);
-            return yield* _(new ValueRef(id as ID<V>, account, this).loadEf());
+            return yield* _(
+                new Ref(id as ID<V>, account, this as CoValueClass<V>).loadEf()
+            );
         });
     }
 
@@ -129,7 +141,7 @@ export class CoValueBase implements CoValue {
             onProgress?: (progress: number) => void;
         }
     ): Promise<V | undefined> {
-        return new ValueRef(id as ID<V>, options.as, this).load(
+        return new Ref(id as ID<V>, options.as, this as CoValueClass<V>).load(
             options?.onProgress && { onProgress: options.onProgress }
         );
     }
@@ -213,4 +225,13 @@ export class CoValueBase implements CoValue {
     [inspect]() {
         return this.toJSON();
     }
+
+    as<C extends CoValueClass>(otherSchema: C): InstanceType<C> {
+        const cast = otherSchema.fromRaw(this._raw) as InstanceType<C>;
+        const subScope = subscriptionsScopes.get(this);
+        if (subScope) {
+            subscriptionsScopes.set(cast, subScope);
+        }
+        return cast;
+    }
 }

package/src/implementation/refs.ts

@@ -5,20 +5,27 @@ import type {
     CoValue,
     ID,
     Me,
-    SubclassedConstructor,
+    RefEncoded,
     UnavailableError,
-    indexSignature,
 } from "../internal.js";
-import { subscriptionsScopes } from "../internal.js";
+import {
+    instantiateRefEncoded,
+    isRefEncoded,
+    subscriptionsScopes,
+} from "../internal.js";
 
-export class ValueRef<V extends CoValue> {
+export class Ref<out 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;
@@ -27,9 +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 {
@@ -63,11 +68,7 @@ export class ValueRef<V extends CoValue> {
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(
-                this.id,
-                this.controlledAccount,
-                this.valueConstructor
-            ).value!;
+            return new Ref(this.id, this.controlledAccount, this.schema).value!;
         }
     }
 
@@ -95,28 +96,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> } & {
-    [Symbol.iterator]: () => IterableIterator<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]: ValueRef<CoValue> } & {
-        [Symbol.iterator]: () => IterableIterator<ValueRef<CoValue>>;
+    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)
                         );
                     }
                 };
@@ -127,14 +128,30 @@ 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() {
             return getKeysWithIds().map((key) => key.toString());
         },
+        getOwnPropertyDescriptor(target, key) {
+            const id = getIdForKey(key as Keys);
+            if (id) {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                };
+            } else {
+                return Reflect.getOwnPropertyDescriptor(target, key);
+            }
+        },
     });
 }
+
+export type RefIfCoValue<V> = NonNullable<V> extends CoValue
+    ? Ref<NonNullable<V>>
+    : never;

package/src/implementation/schema.ts

@@ -1,25 +1,77 @@
-import type { JsonValue } from "cojson";
-import type { CoValue, CoValueClass } from "../internal.js";
-import type { Schema, TypeId } from "@effect/schema/Schema";
+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 PrimitiveField = "json";
-export type EncodedField<V> = { encoded: Encoder<V> };
-export type RefField<V extends CoValue> = {
-    ref: () => CoValueClass<V>;
+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 type UnCo<T> = T extends co<infer A> ? A : T;
+
+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>,
+    null: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<null>,
+    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,
+    members: MembersSym as MembersSym,
 };
 
-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 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 FieldDescriptorFor<Field> = NonNullable<Field> extends CoValue
-    ? RefField<NonNullable<Field>>
+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
@@ -33,37 +85,8 @@ export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
 export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
 
 import { Date } from "@effect/schema/Schema";
+import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";
 
 export const Encoders = {
     Date,
 };
-
-export const indexSignature = Symbol.for("indexSignature");
-export type indexSignature = typeof indexSignature;
-
-export type EnsureCoValueNullable<
-    V,
-    Key extends string | indexSignature,
-> = NonNullable<V> extends CoValue
-    ? null extends V
-        ? V
-        : Key extends string
-          ? [
-                `👋 CoMap fields that are CoValue references should be nullable, declare ${Key} as:`,
-                V | null,
-            ]
-          : [
-                `👋 CoMap fields that are CoValue references should be nullable, declare [indexSignature] 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;

package/src/implementation/symbols.ts

@@ -0,0 +1,12 @@
+
+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 MembersSym = Symbol.for("members");
+export type MembersSym = typeof MembersSym;

package/src/index.ts

@@ -1,23 +1,25 @@
-/** @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/internal.ts

@@ -1,3 +1,4 @@
+export * from "./implementation/symbols.js";
 export * from './implementation/inspect.js';
 export * from "./coValues/interfaces.js";