jazz-tools 0.7.0-alpha.8 → 0.7.1

package/src/coValues/account.ts

@@ -2,6 +2,7 @@ import { LocalNode } from "cojson";
 import type {
     AgentSecret,
     CoID,
+    CryptoProvider,
     InviteSecret,
     Peer,
     RawAccount,
@@ -15,116 +16,98 @@ import type {
     CoMap,
     CoValue,
     CoValueClass,
-    Encoding,
-    Group,
+    Schema,
     ID,
     RefEncoded,
-    SubclassedConstructor,
-    UnavailableError,
+    ClassOf,
+    RefIfCoValue,
 } from "../internal.js";
 import {
+    Group,
     CoValueBase,
+    MembersSym,
     Profile,
     Ref,
     SchemaInit,
     inspect,
     subscriptionsScopes,
 } from "../internal.js";
-import type { Stream } from "effect/Stream";
 
-export class Account<
-        Def extends { profile: Profile | null; root: CoMap | null } = {
-            profile: Profile | null;
-            root: CoMap | null;
-        },
-    >
+/** @category Identity & Permissions */
+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: Encoding;
-        root: Encoding;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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: { ref: () => Profile, optional: false } satisfies Schema,
+            root: "json" satisfies Schema,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any;
     }
 
     get _owner(): Account {
         return this as Account;
     }
-    get _loadedAs(): Account & Me {
-        return this.isMe
-            ? (this as Account & Me)
-            : Account.fromNode(this._raw.core.node);
+    get _loadedAs(): Account {
+        return this.isMe ? this : Account.fromNode(this._raw.core.node);
     }
 
-    profile!: NonNullable<Def["profile"]> | null;
-    root!: NonNullable<Def["root"]> | null;
+    declare profile: Profile | null;
+    declare root: CoMap | null;
 
-    get _refs(): {
-        profile: NonNullable<Def["profile"]> extends Profile
-            ? Ref<NonNullable<Def["profile"]>> | null
-            : null;
-        root: NonNullable<Def["root"]> extends CoMap
-            ? Ref<NonNullable<Def["root"]>> | null
-            : null;
-    } {
+    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 Ref(
                     profileID,
                     this._loadedAs,
-                    this._encoding.profile as RefEncoded<
-                        NonNullable<Def["profile"]> & CoValue
-                    >
-                ) as any),
+                    this._schema.profile as RefEncoded<
+                        NonNullable<this["profile"]> & CoValue
+                    >,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as RefIfCoValue<this["profile"]>),
             root:
                 rootID &&
                 (new Ref(
                     rootID,
                     this._loadedAs,
-                    this._encoding.root as RefEncoded<
-                        NonNullable<Def["root"]> & CoValue
-                    >
-                ) as any),
+                    this._schema.root as RefEncoded<
+                        NonNullable<this["root"]> & CoValue
+                    >,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as RefIfCoValue<this["root"]>),
         };
     }
 
     isMe: boolean;
     sessionID: SessionID | undefined;
 
-    constructor(init: undefined, options: { owner: Group | Account });
-    constructor(
-        init: undefined,
-        options: { fromRaw: RawAccount | RawControlledAccount }
-    );
-    constructor(
-        init: undefined,
-        options:
-            | { fromRaw: RawAccount | RawControlledAccount }
-            | { owner: Group | Account }
-    ) {
+    constructor(options: { fromRaw: RawAccount | RawControlledAccount }) {
         super();
         if (!("fromRaw" in options)) {
             throw new Error(
-                "Can only construct account from raw or with .create()"
+                "Can only construct account from raw or with .create()",
             );
         }
         this.isMe = options.fromRaw.id == options.fromRaw.core.node.account.id;
@@ -135,16 +118,16 @@ export class Account<
                 enumerable: false,
             },
             _raw: { value: options.fromRaw, enumerable: false },
+            _type: { value: "Account", enumerable: false },
         });
 
         if (this.isMe) {
-            (this as Account & Me).sessionID =
-                options.fromRaw.core.node.currentSessionID;
+            this.sessionID = options.fromRaw.core.node.currentSessionID;
         }
 
         return new Proxy(
             this,
-            AccountAndGroupProxyHandler as ProxyHandler<this>
+            AccountAndGroupProxyHandler as ProxyHandler<this>,
         );
     }
 
@@ -154,88 +137,82 @@ export class Account<
         }
     }
 
-    acceptInvite:
-        | (<V extends CoValue>(
-              valueID: ID<V>,
-              inviteSecret: InviteSecret,
-              coValueClass: CoValueClass<V>
-          ) => Promise<V | undefined>)
-        | undefined = (async <V extends CoValue>(
+    async acceptInvite<V extends CoValue>(
         valueID: ID<V>,
         inviteSecret: InviteSecret,
-        coValueClass: CoValueClass<V>
-    ) => {
+        coValueClass: CoValueClass<V>,
+    ) {
         if (!this.isMe) {
             throw new Error("Only a controlled account can accept invites");
         }
 
         await (this._raw as RawControlledAccount).acceptInvite(
             valueID as unknown as CoID<RawCoValue>,
-            inviteSecret
+            inviteSecret,
         );
 
-        return coValueClass.load(valueID, {
-            as: this as Account & Me,
-        });
-    }) as any;
+        return coValueClass.load(valueID, this as Account, []);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
 
     static async create<A extends Account>(
-        this: SubclassedConstructor<A> & typeof Account,
+        this: ClassOf<A> & typeof Account,
         options: {
-            name: string;
+            creationProps: { name: string };
             initialAgentSecret?: AgentSecret;
             peersToLoadFrom?: Peer[];
-        }
-    ): Promise<A & Me> {
+            crypto: CryptoProvider;
+        },
+    ): Promise<A> {
         const { node } = await LocalNode.withNewlyCreatedAccount({
             ...options,
-            migration: async (rawAccount) => {
-                const account = new this(undefined, {
+            migration: async (rawAccount, _node, creationProps) => {
+                const account = new this({
                     fromRaw: rawAccount,
-                }) as A & Me;
+                }) as A;
 
-                await account.migrate?.();
+                await account.migrate?.(creationProps);
             },
         });
 
-        return this.fromNode(node) as A & Me;
+        return this.fromNode(node) as A;
     }
 
     static async become<A extends Account>(
-        this: SubclassedConstructor<A> & typeof Account,
+        this: ClassOf<A> & typeof Account,
         options: {
             accountID: ID<Account>;
             accountSecret: AgentSecret;
-            sessionID: SessionID;
+            sessionID?: SessionID;
             peersToLoadFrom: Peer[];
-        }
-    ): Promise<A & Me> {
+            crypto: CryptoProvider;
+        },
+    ): Promise<A> {
         const node = await LocalNode.withLoadedAccount({
             accountID: options.accountID as unknown as CoID<RawAccount>,
             accountSecret: options.accountSecret,
             sessionID: options.sessionID,
             peersToLoadFrom: options.peersToLoadFrom,
-            migration: async (rawAccount) => {
-                const account = new this(undefined, {
+            crypto: options.crypto,
+            migration: async (rawAccount, _node, creationProps) => {
+                const account = new this({
                     fromRaw: rawAccount,
-                }) as A & Me;
+                }) as A;
 
-                await account.migrate?.();
+                await account.migrate?.(creationProps);
             },
         });
 
-        return this.fromNode(node) as A & Me;
+        return this.fromNode(node) as A;
     }
 
-    static fromNode<A extends Account>(
-        this: SubclassedConstructor<A>,
-        node: LocalNode
-    ): A & Me {
-        return new this(undefined, {
+    static fromNode<A extends Account>(this: ClassOf<A>, node: LocalNode): A {
+        return new this({
             fromRaw: node.account as RawControlledAccount,
-        }) as A & Me;
+        }) as A;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON(): object | any[] {
         return {
             id: this.id,
@@ -247,45 +224,63 @@ export class Account<
         return this.toJSON();
     }
 
-    migrate: (() => void | Promise<void>) | undefined;
+    migrate(creationProps?: { name: string }): void | Promise<void> {
+        if (creationProps) {
+            const profileGroup = Group.create({ owner: this });
+            profileGroup.addMember("everyone", "reader");
+            this.profile = Profile.create(
+                { name: creationProps.name },
+                { owner: profileGroup },
+            );
+        }
+    }
 }
 
 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);
+            return ref
+                ? ref.accessFrom(receiver, "profile")
+                : // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  (undefined as any);
         } else if (key === "root") {
             const ref = target._refs.root;
-            return ref ? ref.accessFrom(receiver) : (undefined as any);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return ref ? ref.accessFrom(receiver, "root") : (undefined as any);
         } else {
             return Reflect.get(target, key, receiver);
         }
     },
     set(target, key, value, receiver) {
         if (
-            (key === "profile" || key === "root") &&
+            (key === "profile" || key === "root" || key === MembersSym) &&
             typeof value === "object" &&
             SchemaInit in value
         ) {
-            (target.constructor as typeof CoMap)._encoding ||= {};
-            (target.constructor as typeof CoMap)._encoding[key] =
+            (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>
+                    value.id as unknown as CoID<RawCoMap>,
+                    "trusting",
                 );
             }
-            subscriptionsScopes.get(receiver)?.onRefAccessedOrSet(value.id);
+            subscriptionsScopes
+                .get(receiver)
+                ?.onRefAccessedOrSet(target.id, 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);
+            subscriptionsScopes
+                .get(receiver)
+                ?.onRefAccessedOrSet(target.id, value.id);
             return true;
         } else {
             return Reflect.set(target, key, value, receiver);
@@ -293,12 +288,12 @@ export const AccountAndGroupProxyHandler: ProxyHandler<Account | Group> = {
     },
     defineProperty(target, key, descriptor) {
         if (
-            (key === "profile" || key === "root") &&
+            (key === "profile" || key === "root" || key === MembersSym) &&
             typeof descriptor.value === "object" &&
             SchemaInit in descriptor.value
         ) {
-            (target.constructor as typeof CoMap)._encoding ||= {};
-            (target.constructor as typeof CoMap)._encoding[key] =
+            (target.constructor as typeof CoMap)._schema ||= {};
+            (target.constructor as typeof CoMap)._schema[key] =
                 descriptor.value[SchemaInit];
             return true;
         } else {
@@ -307,21 +302,14 @@ export const AccountAndGroupProxyHandler: ProxyHandler<Account | Group> = {
     },
 };
 
-export interface Me {
-    id: ID<any>;
+/** @category Identity & Permissions */
+export class AccountCtx extends Context.Tag("Account")<AccountCtx, Account>() {}
+
+/** @category Identity & Permissions */
+export function isControlledAccount(account: Account): account is Account & {
     isMe: true;
-    _raw: RawControlledAccount;
     sessionID: SessionID;
-    subscribe(listener: (update: this & Me) => void): () => void;
-    subscribeEf(): Stream<this & Me, UnavailableError, never>;
-    acceptInvite: (...args: any[]) => any;
-}
-
-export class AccountCtx extends Context.Tag("Account")<
-    AccountCtx,
-    Account & Me
->() {}
-
-export function isControlledAccount(account: Account): account is Account & Me {
+    _raw: RawControlledAccount;
+} {
     return account.isMe;
 }