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

package/src/coValues/account.ts

@@ -15,14 +15,22 @@ import type {
     CoMap,
     CoValue,
     CoValueClass,
-    FieldDescriptor,
-    Group,
+    Schema,
     ID,
-    RefField,
+    RefEncoded,
     SubclassedConstructor,
     UnavailableError,
 } from "../internal.js";
-import { CoValueBase, Profile, ValueRef, inspect } from "../internal.js";
+import {
+    Group,
+    CoValueBase,
+    MembersSym,
+    Profile,
+    Ref,
+    SchemaInit,
+    inspect,
+    subscriptionsScopes,
+} from "../internal.js";
 import type { Stream } from "effect/Stream";
 
 export class Account<
@@ -34,21 +42,21 @@ export class Account<
     extends CoValueBase
     implements CoValue<"Account", RawAccount | RawControlledAccount>
 {
-    id!: ID<this>;
-    _type!: "Account";
-    _raw!: RawAccount | RawControlledAccount;
+    declare id: ID<this>;
+    declare _type: "Account";
+    declare _raw: RawAccount | RawControlledAccount;
 
-    static _encoding: any;
-    get _encoding(): {
-        profile: FieldDescriptor;
-        root: FieldDescriptor;
+    static _schema: any;
+    get _schema(): {
+        profile: Schema;
+        root: Schema;
     } {
-        return (this.constructor as typeof Account)._encoding;
+        return (this.constructor as typeof Account)._schema;
     }
     static {
-        this._encoding = {
-            profile: { ref: () => Profile },
-            root: { json: true },
+        this._schema = {
+            profile: () => Profile satisfies Schema,
+            root: "json" satisfies Schema,
         } as any;
     }
 
@@ -66,36 +74,36 @@ export class Account<
 
     get _refs(): {
         profile: NonNullable<Def["profile"]> extends Profile
-            ? ValueRef<NonNullable<Def["profile"]>> | null
+            ? Ref<NonNullable<Def["profile"]>> | null
             : null;
         root: NonNullable<Def["root"]> extends CoMap
-            ? ValueRef<NonNullable<Def["root"]>> | null
+            ? Ref<NonNullable<Def["root"]>> | null
             : null;
     } {
-        const profileID = this._raw.get("profile") as unknown as ID<
-            NonNullable<Def["profile"]>
-        > | undefined;
+        const profileID = this._raw.get("profile") as unknown as
+            | ID<NonNullable<Def["profile"]>>
+            | undefined;
         const rootID = this._raw.get("root") as unknown as
             | ID<NonNullable<Def["root"]>>
             | undefined;
         return {
-            profile: profileID && (new ValueRef(
-                profileID,
-                this._loadedAs,
-                (
-                    this._encoding.profile as RefField<
+            profile:
+                profileID &&
+                (new Ref(
+                    profileID,
+                    this._loadedAs,
+                    this._schema.profile as RefEncoded<
                         NonNullable<Def["profile"]> & CoValue
                     >
-                ).ref()
-            )) as any,
+                ) as any),
             root:
                 rootID &&
-                (new ValueRef(
+                (new Ref(
                     rootID,
                     this._loadedAs,
-                    (
-                        this._encoding.root as RefField<NonNullable<Def["root"]> & CoValue>
-                    ).ref()
+                    this._schema.root as RefEncoded<
+                        NonNullable<Def["root"]> & CoValue
+                    >
                 ) as any),
         };
     }
@@ -109,7 +117,7 @@ export class Account<
         options: { fromRaw: RawAccount | RawControlledAccount }
     );
     constructor(
-        init: undefined,
+        _init: undefined,
         options:
             | { fromRaw: RawAccount | RawControlledAccount }
             | { owner: Group | Account }
@@ -128,40 +136,17 @@ export class Account<
                 enumerable: false,
             },
             _raw: { value: options.fromRaw, 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>
-                        );
-                    }
-                },
-            },
         });
 
         if (this.isMe) {
             (this as Account & Me).sessionID =
                 options.fromRaw.core.node.currentSessionID;
         }
+
+        return new Proxy(
+            this,
+            AccountAndGroupProxyHandler as ProxyHandler<this>
+        );
     }
 
     myRole(): "admin" | undefined {
@@ -198,19 +183,19 @@ export class Account<
     static async create<A extends Account>(
         this: SubclassedConstructor<A> & typeof Account,
         options: {
-            name: string;
+            creationProps: { name: string };
             initialAgentSecret?: AgentSecret;
             peersToLoadFrom?: Peer[];
         }
     ): Promise<A & Me> {
         const { node } = await LocalNode.withNewlyCreatedAccount({
             ...options,
-            migration: async (rawAccount) => {
+            migration: async (rawAccount, _node, creationProps) => {
                 const account = new this(undefined, {
                     fromRaw: rawAccount,
                 }) as A & Me;
 
-                await account.migrate?.();
+                await account.migrate?.(creationProps);
             },
         });
 
@@ -231,12 +216,12 @@ export class Account<
             accountSecret: options.accountSecret,
             sessionID: options.sessionID,
             peersToLoadFrom: options.peersToLoadFrom,
-            migration: async (rawAccount) => {
+            migration: async (rawAccount, _node, creationProps) => {
                 const account = new this(undefined, {
                     fromRaw: rawAccount,
                 }) as A & Me;
 
-                await account.migrate?.();
+                await account.migrate?.(creationProps);
             },
         });
 
@@ -263,20 +248,76 @@ export class Account<
         return this.toJSON();
     }
 
-    static encoding<V extends Account>(
-        this: { new (...args: any[]): V } & CoValueClass<V> & { _encoding: any },
-        fields: {
-            profile: V["_encoding"]["profile"];
-            root: V["_encoding"]["root"];
+    migrate(creationProps?: { name: string }): void | Promise<void> {
+        if (creationProps) {
+            const profileGroup = new Group({ owner: this });
+            profileGroup.addMember("everyone", "reader");
+            this.profile = new Profile(
+                { name: creationProps.name },
+                { owner: profileGroup }
+            );
         }
-    ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, fields);
     }
-
-    migrate: (() => void | Promise<void>) | undefined;
 }
 
+export const AccountAndGroupProxyHandler: ProxyHandler<Account | Group> = {
+    get(target, key, receiver) {
+        if (key === "profile") {
+            const ref = target._refs.profile;
+            return ref ? ref.accessFrom(receiver) : (undefined as any);
+        } else if (key === "root") {
+            const ref = target._refs.root;
+            return ref ? ref.accessFrom(receiver) : (undefined as any);
+        } else {
+            return Reflect.get(target, key, receiver);
+        }
+    },
+    set(target, key, value, receiver) {
+        if (
+            (key === "profile" || key === "root" || key === MembersSym) &&
+            typeof value === "object" &&
+            SchemaInit in value
+        ) {
+            (target.constructor as typeof CoMap)._schema ||= {};
+            (target.constructor as typeof CoMap)._schema[key] =
+                value[SchemaInit];
+            return true;
+        } else if (key === "profile") {
+            if (value) {
+                target._raw.set(
+                    "profile",
+                    value.id as unknown as CoID<RawCoMap>,
+                    "trusting"
+                );
+            }
+            subscriptionsScopes.get(receiver)?.onRefAccessedOrSet(value.id);
+            return true;
+        } else if (key === "root") {
+            if (value) {
+                target._raw.set("root", value.id as unknown as CoID<RawCoMap>);
+            }
+            subscriptionsScopes.get(receiver)?.onRefAccessedOrSet(value.id);
+            return true;
+        } else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    },
+    defineProperty(target, key, descriptor) {
+        if (
+            (key === "profile" || key === "root" || key === MembersSym) &&
+            typeof descriptor.value === "object" &&
+            SchemaInit in descriptor.value
+        ) {
+            (target.constructor as typeof CoMap)._schema ||= {};
+            (target.constructor as typeof CoMap)._schema[key] =
+                descriptor.value[SchemaInit];
+            return true;
+        } else {
+            return Reflect.defineProperty(target, key, descriptor);
+        }
+    },
+};
+
 export interface Me {
     id: ID<any>;
     isMe: true;