cojson 0.3.6 → 0.4.0

package/src/localNode.ts

@@ -17,16 +17,16 @@ import {
 import {
     InviteSecret,
     Group,
-    GroupContent,
-    expectGroupContent,
+    GroupShape,
+    expectGroup,
     secretSeedFromInviteSecret,
-} from "./group.js";
+} from "./coValues/group.js";
 import { Peer, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
 import { CoID } from "./coValue.js";
 import { Queried, query } from "./queries.js";
 import {
-    AccountGroup,
+    Account,
     AccountMeta,
     accountHeaderForInitialAgentSecret,
     GeneralizedControlledAccount,
@@ -34,10 +34,12 @@ import {
     AnonymousControlledAccount,
     AccountID,
     Profile,
-    AccountContent,
-} from "./account.js";
+    isAccountID,
+    AccountMigration,
+} from "./coValues/account.js";
 import { CoMap } from "./coValues/coMap.js";
 import { CoValue } from "./index.js";
+import { QueriedAccount } from "./queriedCoValues/queriedAccount.js";
 
 /** A `LocalNode` represents a local view of a set of loaded `CoValue`s, from the perspective of a particular account (or primitive cryptographic agent).
 
@@ -70,10 +72,19 @@ export class LocalNode {
     }
 
     /** @category 2. Node Creation */
-    static withNewlyCreatedAccount(
-        name: string,
-        initialAgentSecret = newRandomAgentSecret()
-    ): {
+    static withNewlyCreatedAccount<
+        P extends Profile = Profile,
+        R extends CoMap = CoMap,
+        Meta extends AccountMeta = AccountMeta
+    >({
+        name,
+        migration,
+        initialAgentSecret = newRandomAgentSecret(),
+    }: {
+        name: string;
+        migration?: AccountMigration<P, R, Meta>;
+        initialAgentSecret?: AgentSecret;
+    }): {
         node: LocalNode;
         accountID: AccountID;
         accountSecret: AgentSecret;
@@ -87,26 +98,52 @@ export class LocalNode {
 
         const account = setupNode.createAccount(name, initialAgentSecret);
 
-        const nodeWithAccount = account.node.testWithDifferentAccount(
+        const nodeWithAccount = account.core.node.testWithDifferentAccount(
             account,
             newRandomSessionID(account.id)
         );
 
+        const accountOnNodeWithAccount = nodeWithAccount.account as ControlledAccount<P, R, Meta>;
+
+        const profile = nodeWithAccount.expectProfileLoaded(
+            accountOnNodeWithAccount.id,
+            "After creating account"
+        );
+
+        if (migration) {
+            migration(accountOnNodeWithAccount, profile as P);
+            nodeWithAccount.account = new ControlledAccount(
+                accountOnNodeWithAccount.core,
+                accountOnNodeWithAccount.agentSecret
+            );
+        }
+
         return {
             node: nodeWithAccount,
-            accountID: account.id,
-            accountSecret: account.agentSecret,
+            accountID: accountOnNodeWithAccount.id,
+            accountSecret: accountOnNodeWithAccount.agentSecret,
             sessionID: nodeWithAccount.currentSessionID,
         };
     }
 
     /** @category 2. Node Creation */
-    static async withLoadedAccount(
-        accountID: AccountID,
-        accountSecret: AgentSecret,
-        sessionID: SessionID,
-        peersToLoadFrom: Peer[]
-    ): Promise<LocalNode> {
+    static async withLoadedAccount<
+        P extends Profile = Profile,
+        R extends CoMap = CoMap,
+        Meta extends AccountMeta = AccountMeta
+    >({
+        accountID,
+        accountSecret,
+        sessionID,
+        peersToLoadFrom,
+        migration,
+    }: {
+        accountID: AccountID;
+        accountSecret: AgentSecret;
+        sessionID: SessionID;
+        peersToLoadFrom: Peer[];
+        migration?: AccountMigration<P, R, Meta>;
+    }): Promise<LocalNode> {
         const loadingNode = new LocalNode(
             new AnonymousControlledAccount(accountSecret),
             newRandomSessionID(accountID)
@@ -119,15 +156,38 @@ export class LocalNode {
         }
 
         const account = await accountPromise;
+        const controlledAccount = new ControlledAccount(
+            account.core,
+            accountSecret
+        );
 
         // since this is all synchronous, we can just swap out nodes for the SyncManager
         const node = loadingNode.testWithDifferentAccount(
-            new ControlledAccount(accountSecret, account, loadingNode),
+            controlledAccount,
             sessionID
         );
         node.syncManager = loadingNode.syncManager;
         node.syncManager.local = node;
 
+        controlledAccount.core.node = node;
+
+        const profileID = account.get("profile");
+        if (!profileID) {
+            throw new Error("Account has no profile");
+        }
+        const profile = await node.load(profileID);
+
+        if (migration) {
+            migration(
+                controlledAccount as ControlledAccount<P, R, Meta>,
+                profile as P
+            );
+            node.account = new ControlledAccount(
+                controlledAccount.core,
+                controlledAccount.agentSecret
+            );
+        }
+
         return node;
     }
 
@@ -197,14 +257,47 @@ export class LocalNode {
     }
 
     /** @category 1. High-level */
+
     query<T extends CoValue>(
         id: CoID<T>,
         callback: (update: Queried<T> | undefined) => void
+    ): () => void;
+    query<
+        P extends Profile = Profile,
+        R extends CoMap = CoMap,
+        Meta extends AccountMeta = AccountMeta
+    >(
+        id: "me",
+        callback: (
+            update: QueriedAccount<Account<P, R, Meta>> | undefined
+        ) => void
+    ): () => void;
+    query(
+        id: CoID<CoValue> | "me",
+        callback: (
+            update: Queried<CoValue> | QueriedAccount | undefined
+        ) => void
+    ): () => void;
+    query(
+        id: CoID<CoValue> | "me",
+        callback: (
+            // TODO: sort this out
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            update: any
+        ) => void
     ): () => void {
-        return query(id, this, callback);
+        if (id === "me") {
+            const meId = this.account.id;
+            if (!isAccountID(meId)) {
+                throw new Error("Can only query 'me' for accounts");
+            }
+            return query(meId, this, callback);
+        } else {
+            return query(id, this, callback);
+        }
     }
 
-    /** @category 1. High-level */
+    /** @deprecated Use Account.acceptInvite instead */
     async acceptInvite<T extends CoValue>(
         groupOrOwnedValueID: CoID<T>,
         inviteSecret: InviteSecret
@@ -213,16 +306,14 @@ export class LocalNode {
 
         if (groupOrOwnedValue.core.header.ruleset.type === "ownedByGroup") {
             return this.acceptInvite(
-                groupOrOwnedValue.core.header.ruleset.group as CoID<
-                    CoMap<GroupContent>
-                >,
+                groupOrOwnedValue.core.header.ruleset.group as CoID<Group>,
                 inviteSecret
             );
         } else if (groupOrOwnedValue.core.header.ruleset.type !== "group") {
             throw new Error("Can only accept invites to groups");
         }
 
-        const group = new Group(expectGroupContent(groupOrOwnedValue), this);
+        const group = expectGroup(groupOrOwnedValue);
 
         const inviteAgentSecret = agentSecretFromSecretSeed(
             secretSeedFromInviteSecret(inviteSecret)
@@ -230,8 +321,8 @@ export class LocalNode {
         const inviteAgentID = getAgentID(inviteAgentSecret);
 
         const inviteRole = await new Promise((resolve, reject) => {
-            group.underlyingMap.subscribe((groupMap) => {
-                const role = groupMap.get(inviteAgentID);
+            group.subscribe((groupUpdate) => {
+                const role = groupUpdate.get(inviteAgentID);
                 if (role) {
                     resolve(role);
                 }
@@ -246,7 +337,7 @@ export class LocalNode {
             throw new Error("No invite found");
         }
 
-        const existingRole = group.underlyingMap.get(this.account.id);
+        const existingRole = group.get(this.account.id);
 
         if (
             existingRole === "admin" ||
@@ -260,9 +351,13 @@ export class LocalNode {
             return;
         }
 
-        const groupAsInvite = group.testWithDifferentAccount(
-            new AnonymousControlledAccount(inviteAgentSecret),
-            newRandomSessionID(inviteAgentID)
+        const groupAsInvite = expectGroup(
+            group.core
+                .testWithDifferentAccount(
+                    new AnonymousControlledAccount(inviteAgentSecret),
+                    newRandomSessionID(inviteAgentID)
+                )
+                .getCurrentContent()
         );
 
         groupAsInvite.addMemberInternal(
@@ -274,12 +369,11 @@ export class LocalNode {
                 : "reader"
         );
 
-        group.underlyingMap.core._sessions =
-            groupAsInvite.underlyingMap.core.sessions;
-        group.underlyingMap.core._cachedContent = undefined;
+        group.core._sessions = groupAsInvite.core.sessions;
+        group.core._cachedContent = undefined;
 
-        for (const groupListener of group.underlyingMap.core.listeners) {
-            groupListener(group.underlyingMap.core.getCurrentContent());
+        for (const groupListener of group.core.listeners) {
+            groupListener(group.core.getCurrentContent());
         }
     }
 
@@ -304,7 +398,7 @@ export class LocalNode {
     /** @internal */
     expectProfileLoaded(id: AccountID, expectation?: string): Profile {
         const account = this.expectCoValueLoaded(id, expectation);
-        const profileID = expectGroupContent(account.getCurrentContent()).get(
+        const profileID = expectGroup(account.getCurrentContent()).get(
             "profile"
         );
         if (!profileID) {
@@ -326,47 +420,51 @@ export class LocalNode {
         agentSecret = newRandomAgentSecret()
     ): ControlledAccount {
         const accountAgentID = getAgentID(agentSecret);
-        const account = this.createCoValue(
-            accountHeaderForInitialAgentSecret(agentSecret)
-        ).testWithDifferentAccount(
-            new AnonymousControlledAccount(agentSecret),
-            newRandomSessionID(accountAgentID)
-        );
-
-        const accountAsGroup = new Group(
-            expectGroupContent(account.getCurrentContent()),
-            account.node
+        let account = expectGroup(
+            this.createCoValue(accountHeaderForInitialAgentSecret(agentSecret))
+                .testWithDifferentAccount(
+                    new AnonymousControlledAccount(agentSecret),
+                    newRandomSessionID(accountAgentID)
+                )
+                .getCurrentContent()
         );
 
-        accountAsGroup.underlyingMap.mutate((editable) => {
+        account = account.mutate((editable) => {
             editable.set(accountAgentID, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
 
+            const sealed = seal({
+                message: readKey.secret,
+                from: getAgentSealerSecret(agentSecret),
+                to: getAgentSealerID(accountAgentID),
+                nOnceMaterial: {
+                    in: account.id,
+                    tx: account.core.nextTransactionID(),
+                },
+            });
+
+            console.log(
+                "Creating read key",
+                getAgentSealerSecret(agentSecret),
+                getAgentSealerID(accountAgentID),
+                account.id,
+                account.core.nextTransactionID(),
+                "in session",
+                account.core.node.currentSessionID,
+                "=",
+                sealed
+            );
             editable.set(
                 `${readKey.id}_for_${accountAgentID}`,
-                seal({
-                    message: readKey.secret,
-                    from: getAgentSealerSecret(agentSecret),
-                    to: getAgentSealerID(accountAgentID),
-                    nOnceMaterial: {
-                        in: account.id,
-                        tx: account.nextTransactionID(),
-                    },
-                }),
+                sealed,
                 "trusting"
             );
 
             editable.set("readKey", readKey.id, "trusting");
         });
 
-        const controlledAccount = new ControlledAccount(
-            agentSecret,
-            account.getCurrentContent() as CoMap<AccountContent, AccountMeta>,
-            account.node
-        );
-
-        const profile = accountAsGroup.createMap<Profile>(
+        const profile = account.createMap<Profile>(
             { name },
             {
                 type: "profile",
@@ -374,12 +472,12 @@ export class LocalNode {
             "trusting"
         );
 
-        accountAsGroup.underlyingMap.set("profile", profile.id, "trusting");
+        account = account.set("profile", profile.id, "trusting");
 
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
         accountOnThisNode._sessions = {
-            ...accountAsGroup.underlyingMap.core.sessions,
+            ...account.core.sessions,
         };
         accountOnThisNode._cachedContent = undefined;
 
@@ -390,7 +488,7 @@ export class LocalNode {
         };
         profileOnThisNode._cachedContent = undefined;
 
-        return controlledAccount;
+        return new ControlledAccount(accountOnThisNode, agentSecret);
     }
 
     /** @internal */
@@ -418,15 +516,11 @@ export class LocalNode {
             );
         }
 
-        return new AccountGroup(
-            coValue.getCurrentContent() as CoMap<GroupContent, AccountMeta>,
-            this
-        ).getCurrentAgentID();
+        return new Account(coValue).getCurrentAgentID();
     }
 
     /**
-     * Creates a new group (with the current account as the group's first admin).
-     * @category 1. High-level
+     * @deprecated use Account.createGroup() instead
      */
     createGroup(): Group {
         const groupCoValue = this.createCoValue({
@@ -436,9 +530,9 @@ export class LocalNode {
             ...createdNowUnique(),
         });
 
-        let groupContent = expectGroupContent(groupCoValue.getCurrentContent());
+        let group = expectGroup(groupCoValue.getCurrentContent());
 
-        groupContent = groupContent.mutate((editable) => {
+        group = group.mutate((editable) => {
             editable.set(this.account.id, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
@@ -460,7 +554,7 @@ export class LocalNode {
             editable.set("readKey", readKey.id, "trusting");
         });
 
-        return new Group(groupContent, this);
+        return group;
     }
 
     /** @internal */
@@ -505,6 +599,15 @@ export class LocalNode {
             }
         }
 
+        if (account instanceof ControlledAccount) {
+            // To make sure that when we edit the account, we're modifying the correct sessions
+            const accountInNode = new ControlledAccount(newNode.expectCoValueLoaded(account.id), account.agentSecret);
+            if (accountInNode.core.node !== newNode) {
+                throw new Error("Account's node is not the new node");
+            }
+            newNode.account = accountInNode;
+        }
+
         return newNode;
     }
 }

package/src/media.ts

@@ -4,5 +4,5 @@ import { BinaryCoStream } from './coValues/coStream.js'
 export type ImageDefinition = CoMap<{
     originalSize: [number, number];
     placeholderDataURL?: string;
-    [res: `${number}x${number}`]: BinaryCoStream;
+    [res: `${number}x${number}`]: BinaryCoStream["id"];
 }>;

package/src/permissions.ts

@@ -5,13 +5,12 @@ import { KeyID } from "./crypto.js";
 import {
     CoValueCore,
     Transaction,
-    TrustingTransaction,
     accountOrAgentIDfromSessionID,
 } from "./coValueCore.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
-import { AccountID, Profile } from "./account.js";
+import { Account, AccountID, Profile } from "./coValues/account.js";
 import { parseJSON } from "./jsonStringify.js";
-import { expectGroupContent } from "./group.js";
+import { EVERYONE, Everyone, expectGroup } from "./coValues/group.js";
 
 export type PermissionsDef =
     | { type: "group"; initialAdmin: AccountID | AgentID }
@@ -31,26 +30,21 @@ export function determineValidTransactions(
     coValue: CoValueCore
 ): { txID: TransactionID; tx: Transaction }[] {
     if (coValue.header.ruleset.type === "group") {
-        const allTrustingTransactionsSorted = Object.entries(
-            coValue.sessions
-        ).flatMap(([sessionID, sessionLog]) => {
-            return sessionLog.transactions
-                .map((tx, txIndex) => ({ sessionID, txIndex, tx }))
-                .filter(({ tx }) => {
-                    if (tx.privacy === "trusting") {
-                        return true;
-                    } else {
-                        console.warn("Unexpected private transaction in Group");
-                        return false;
-                    }
-                }) as {
-                sessionID: SessionID;
-                txIndex: number;
-                tx: TrustingTransaction;
-            }[];
-        });
+        const allTransactionsSorted = Object.entries(coValue.sessions).flatMap(
+            ([sessionID, sessionLog]) => {
+                return sessionLog.transactions.map((tx, txIndex) => ({
+                    sessionID,
+                    txIndex,
+                    tx,
+                })) as {
+                    sessionID: SessionID;
+                    txIndex: number;
+                    tx: Transaction;
+                }[];
+            }
+        );
 
-        allTrustingTransactionsSorted.sort((a, b) => {
+        allTransactionsSorted.sort((a, b) => {
             return a.tx.madeAt - b.tx.madeAt;
         });
 
@@ -60,19 +54,33 @@ export function determineValidTransactions(
             throw new Error("Group must have initialAdmin");
         }
 
-        const memberState: { [agent: AccountID | AgentID]: Role } = {};
+        const memberState: {
+            [agent: AccountID | AgentID]: Role;
+            [EVERYONE]?: Role;
+        } = {};
 
         const validTransactions: { txID: TransactionID; tx: Transaction }[] =
             [];
 
-        for (const {
-            sessionID,
-            txIndex,
-            tx,
-        } of allTrustingTransactionsSorted) {
+        for (const { sessionID, txIndex, tx } of allTransactionsSorted) {
             // console.log("before", { memberState, validTransactions });
             const transactor = accountOrAgentIDfromSessionID(sessionID);
 
+            if (tx.privacy === "private") {
+                if (memberState[transactor] === "admin") {
+                    validTransactions.push({
+                        txID: { sessionID, txIndex },
+                        tx,
+                    });
+                    continue;
+                } else {
+                    console.warn(
+                        "Only admins can make private transactions in groups"
+                    );
+                    continue;
+                }
+            }
+
             let changes;
 
             try {
@@ -93,7 +101,7 @@ export function determineValidTransactions(
             }
 
             const change = changes[0] as
-                | MapOpPayload<AccountID | AgentID, Role>
+                | MapOpPayload<AccountID | AgentID | Everyone, Role>
                 | MapOpPayload<"readKey", JsonValue>
                 | MapOpPayload<"profile", CoID<Profile>>;
             if (changes.length !== 1) {
@@ -158,6 +166,20 @@ export function determineValidTransactions(
                 continue;
             }
 
+            if (
+                affectedMember === EVERYONE &&
+                !(
+                    change.value === "reader" ||
+                    change.value === "writer" ||
+                    change.value === "revoked"
+                )
+            ) {
+                console.warn(
+                    "Everyone can only be set to reader, writer or revoked"
+                );
+                continue;
+            }
+
             const isFirstSelfAppointment =
                 !memberState[transactor] &&
                 transactor === initialAdmin &&
@@ -206,7 +228,7 @@ export function determineValidTransactions(
 
         return validTransactions;
     } else if (coValue.header.ruleset.type === "ownedByGroup") {
-        const groupContent = expectGroupContent(
+        const groupContent = expectGroup(
             coValue.node
                 .expectCoValueLoaded(
                     coValue.header.ruleset.group,
@@ -224,11 +246,18 @@ export function determineValidTransactions(
                 const transactor = accountOrAgentIDfromSessionID(
                     sessionID as SessionID
                 );
+
                 return sessionLog.transactions
                     .filter((tx) => {
-                        const transactorRoleAtTxTime = groupContent
-                            .atTime(tx.madeAt)
-                            .get(transactor);
+                        const groupAtTime = groupContent.atTime(tx.madeAt);
+                        const effectiveTransactor =
+                            transactor === groupContent.id &&
+                            groupAtTime instanceof Account
+                                ? groupAtTime.getCurrentAgentID()
+                                : transactor;
+                        const transactorRoleAtTxTime =
+                            groupAtTime.get(effectiveTransactor) ||
+                            groupAtTime.get(EVERYONE);
 
                         return (
                             transactorRoleAtTxTime === "admin" ||
@@ -252,7 +281,8 @@ export function determineValidTransactions(
         );
     } else {
         throw new Error(
-            "Unknown ruleset type " + (coValue.header.ruleset as {type: string}).type
+            "Unknown ruleset type " +
+                (coValue.header.ruleset as { type: string }).type
         );
     }
 }
@@ -267,7 +297,8 @@ export function isKeyForAccountField(
     field: string
 ): field is `${KeyID}_for_${AccountID | AgentID}` {
     return (
-        field.startsWith("key_") &&
-        (field.includes("_for_sealer") || field.includes("_for_co"))
+        (field.startsWith("key_") &&
+            (field.includes("_for_sealer") || field.includes("_for_co"))) ||
+        field.includes("_for_everyone")
     );
 }

package/src/queriedCoValues/queriedAccount.ts

@@ -0,0 +1,40 @@
+import { Account } from "../coValues/account.js";
+import { CoID, CoValue, ControlledAccount, InviteSecret } from "../index.js";
+import { QueryContext } from "../queries.js";
+import { QueriedGroup } from "./queriedGroup.js";
+
+export class QueriedAccount<A extends Account = Account> extends QueriedGroup<A> {
+    id!: CoID<A>;
+    isMe!: boolean;
+
+    constructor(account: A, queryContext: QueryContext) {
+        super(account, queryContext);
+        Object.defineProperties(this, {
+            id: { value: account.id, enumerable: false },
+            isMe: {
+                value: account.core.node.account.id === account.id,
+                enumerable: false,
+            },
+        });
+    }
+
+    createGroup() {
+        if (!this.isMe)
+            throw new Error("Only the current user can create a group");
+        return (
+            this.group.core.node.account as ControlledAccount
+        ).createGroup();
+    }
+
+    acceptInvite<T extends CoValue>(
+        groupOrOwnedValueID: CoID<T>,
+        inviteSecret: InviteSecret
+    ) {
+        if (!this.isMe)
+            throw new Error("Only the current user can accept an invite");
+        return (this.group.core.node.account as ControlledAccount).acceptInvite(
+            groupOrOwnedValueID,
+            inviteSecret
+        );
+    }
+}