jazz-tools 0.7.0-alpha.9 → 0.7.3

package/src/coValues/account.ts

@@ -2,6 +2,7 @@ import { LocalNode } from "cojson";
 import type {
     AgentSecret,
     CoID,
+    CryptoProvider,
     InviteSecret,
     Peer,
     RawAccount,
@@ -10,121 +11,111 @@ import type {
     RawControlledAccount,
     SessionID,
 } from "cojson";
-import { Context } from "effect";
+import { Context, Effect, Stream } from "effect";
 import type {
     CoMap,
     CoValue,
     CoValueClass,
-    Encoding,
-    Group,
+    Schema,
     ID,
     RefEncoded,
-    SubclassedConstructor,
+    RefIfCoValue,
+    DeeplyLoaded,
+    DepthsIn,
     UnavailableError,
 } from "../internal.js";
 import {
+    Group,
     CoValueBase,
+    MembersSym,
     Profile,
     Ref,
     SchemaInit,
     inspect,
     subscriptionsScopes,
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    ensureCoValueLoaded,
+    subscribeToExistingCoValue,
 } 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;
-        },
-    >
-    extends CoValueBase
-    implements CoValue<"Account", RawAccount | RawControlledAccount>
-{
-    id!: ID<this>;
-    _type!: "Account";
-    _raw!: RawAccount | RawControlledAccount;
-
-    static _encoding: any;
-    get _encoding(): {
-        profile: Encoding;
-        root: Encoding;
+/** @category Identity & Permissions */
+export class Account extends CoValueBase implements CoValue {
+    declare id: ID<this>;
+    declare _type: "Account";
+    declare _raw: RawAccount | RawControlledAccount;
+
+    // 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 RefEncoded<Profile>,
+            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 +126,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 +145,85 @@ 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 loadCoValue(coValueClass, 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: CoValueClass<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: CoValueClass<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, {
+        this: CoValueClass<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 +235,122 @@ export class Account<
         return this.toJSON();
     }
 
-    migrate: (() => void | Promise<void>) | undefined;
+    migrate(
+        this: Account,
+        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 },
+            );
+        }
+    }
+
+    /** @category Subscription & Loading */
+    static load<A extends Account, Depth>(
+        this: CoValueClass<A>,
+        id: ID<A>,
+        as: Account,
+        depth: Depth & DepthsIn<A>,
+    ): Promise<DeeplyLoaded<A, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<A extends Account, Depth>(
+        this: CoValueClass<A>,
+        id: ID<A>,
+        depth: Depth & DepthsIn<A>,
+    ): Effect.Effect<DeeplyLoaded<A, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<A, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<A extends Account, Depth>(
+        this: CoValueClass<A>,
+        id: ID<A>,
+        as: Account,
+        depth: Depth & DepthsIn<A>,
+        listener: (value: DeeplyLoaded<A, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<A, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<A extends Account, Depth>(
+        this: CoValueClass<A>,
+        id: ID<A>,
+        depth: Depth & DepthsIn<A>,
+    ): Stream.Stream<DeeplyLoaded<A, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<A, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<A extends Account, Depth>(
+        this: A,
+        depth: Depth & DepthsIn<A>,
+    ): Promise<DeeplyLoaded<A, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<A extends Account, Depth>(
+        this: A,
+        depth: Depth & DepthsIn<A>,
+        listener: (value: DeeplyLoaded<A, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
+    }
 }
 
 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 +358,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 +372,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;
 }