cojson 0.0.21 → 0.0.23

package/src/coValue.ts

@@ -24,11 +24,10 @@ import { JsonObject, JsonValue } from "./jsonValue.js";
 import { base58 } from "@scure/base";
 import {
     PermissionsDef as RulesetDef,
-    Team,
     determineValidTransactions,
-    expectTeamContent,
     isKeyForKeyField,
 } from "./permissions.js";
+import { Team, expectTeamContent } from "./team.js";
 import { LocalNode } from "./node.js";
 import { CoValueKnownState, NewContentMessage } from "./sync.js";
 import { RawCoID, SessionID, TransactionID } from "./ids.js";
@@ -97,15 +96,31 @@ export class CoValue {
     id: RawCoID;
     node: LocalNode;
     header: CoValueHeader;
-    sessions: { [key: SessionID]: SessionLog };
-    content?: ContentType;
+    _sessions: { [key: SessionID]: SessionLog };
+    _cachedContent?: ContentType;
     listeners: Set<(content?: ContentType) => void> = new Set();
 
-    constructor(header: CoValueHeader, node: LocalNode) {
+    constructor(header: CoValueHeader, node: LocalNode, internalInitSessions: { [key: SessionID]: SessionLog } = {}) {
         this.id = idforHeader(header);
         this.header = header;
-        this.sessions = {};
+        this._sessions = internalInitSessions;
         this.node = node;
+
+        if (header.ruleset.type == "ownedByTeam") {
+            this.node
+                .expectCoValueLoaded(header.ruleset.team)
+                .subscribe((_teamUpdate) => {
+                    this._cachedContent = undefined;
+                    const newContent = this.getCurrentContent();
+                    for (const listener of this.listeners) {
+                        listener(newContent);
+                    }
+                });
+        }
+    }
+
+    get sessions(): Readonly<{ [key: SessionID]: SessionLog }> {
+        return this._sessions;
     }
 
     testWithDifferentAccount(
@@ -172,7 +187,10 @@ export class CoValue {
         );
 
         if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-            console.warn("Invalid hash", { expectedNewHash, givenExpectedNewHash });
+            console.warn("Invalid hash", {
+                expectedNewHash,
+                givenExpectedNewHash,
+            });
             return false;
         }
 
@@ -190,14 +208,14 @@ export class CoValue {
 
         transactions.push(...newTransactions);
 
-        this.sessions[sessionID] = {
+        this._sessions[sessionID] = {
             transactions,
             lastHash: expectedNewHash,
             streamingHash: newStreamingHash,
             lastSignature: newSignature,
         };
 
-        this.content = undefined;
+        this._cachedContent = undefined;
 
         const content = this.getCurrentContent();
 
@@ -296,23 +314,23 @@ export class CoValue {
     }
 
     getCurrentContent(): ContentType {
-        if (this.content) {
-            return this.content;
+        if (this._cachedContent) {
+            return this._cachedContent;
         }
 
         if (this.header.type === "comap") {
-            this.content = new CoMap(this);
+            this._cachedContent = new CoMap(this);
         } else if (this.header.type === "colist") {
-            this.content = new CoList(this);
+            this._cachedContent = new CoList(this);
         } else if (this.header.type === "costream") {
-            this.content = new CoStream(this);
+            this._cachedContent = new CoStream(this);
         } else if (this.header.type === "static") {
-            this.content = new Static(this);
+            this._cachedContent = new Static(this);
         } else {
             throw new Error(`Unknown coValue type ${this.header.type}`);
         }
 
-        return this.content;
+        return this._cachedContent;
     }
 
     getValidSortedTransactions(): DecryptedTransaction[] {
@@ -399,7 +417,9 @@ export class CoValue {
 
             // Try to find key revelation for us
 
-            const readKeyEntry = content.getLastEntry(`${keyID}_for_${this.node.account.id}`);
+            const readKeyEntry = content.getLastEntry(
+                `${keyID}_for_${this.node.account.id}`
+            );
 
             if (readKeyEntry) {
                 const revealer = accountOrAgentIDfromSessionID(
@@ -428,7 +448,8 @@ export class CoValue {
             for (const field of content.keys()) {
                 if (isKeyForKeyField(field) && field.startsWith(keyID)) {
                     const encryptingKeyID = field.split("_for_")[1] as KeyID;
-                    const encryptingKeySecret = this.getReadKey(encryptingKeyID);
+                    const encryptingKeySecret =
+                        this.getReadKey(encryptingKeyID);
 
                     if (!encryptingKeySecret) {
                         continue;
@@ -453,7 +474,6 @@ export class CoValue {
                         );
                     }
                 }
-
             }
 
             return undefined;
@@ -525,10 +545,7 @@ export class CoValue {
             ),
         };
 
-        if (
-            !newContent.header &&
-            Object.keys(newContent.new).length === 0
-        ) {
+        if (!newContent.header && Object.keys(newContent.new).length === 0) {
             return undefined;
         }
 
@@ -544,4 +561,4 @@ export class CoValue {
             ? [this.header.ruleset.team]
             : [];
     }
-}
+}

package/src/contentTypes/coMap.ts

@@ -12,12 +12,12 @@ type MapOp<K extends string, V extends JsonValue> = {
 // TODO: add after TransactionID[] for conflicts/ordering
 
 export type MapOpPayload<K extends string, V extends JsonValue> = {
-    op: "insert";
+    op: "set";
     key: K;
     value: V;
 } |
 {
-    op: "delete";
+    op: "del";
     key: K;
 };
 
@@ -81,7 +81,7 @@ export class CoMap<
 
         const lastEntry = ops[ops.length - 1]!;
 
-        if (lastEntry.op === "delete") {
+        if (lastEntry.op === "del") {
             return undefined;
         } else {
             return lastEntry.value;
@@ -100,7 +100,7 @@ export class CoMap<
             return undefined;
         }
 
-        if (lastOpBeforeOrAtTime.op === "delete") {
+        if (lastOpBeforeOrAtTime.op === "del") {
             return undefined;
         } else {
             return lastOpBeforeOrAtTime.value;
@@ -139,7 +139,7 @@ export class CoMap<
 
         const lastEntry = ops[ops.length - 1]!;
 
-        if (lastEntry.op === "delete") {
+        if (lastEntry.op === "del") {
             return undefined;
         } else {
             return { at: lastEntry.madeAt, txID: lastEntry.txID, value: lastEntry.value };
@@ -155,7 +155,7 @@ export class CoMap<
         const history: { at: number; txID: TransactionID; value: M[K] | undefined; }[] = [];
 
         for (const op of ops) {
-            if (op.op === "delete") {
+            if (op.op === "del") {
                 history.push({ at: op.madeAt, txID: op.txID, value: undefined });
             } else {
                 history.push({ at: op.madeAt, txID: op.txID, value: op.value });
@@ -199,7 +199,7 @@ export class WriteableCoMap<
     set<K extends MapK<M>>(key: K, value: M[K], privacy: "private" | "trusting" = "private"): void {
         this.coValue.makeTransaction([
             {
-                op: "insert",
+                op: "set",
                 key,
                 value,
             },
@@ -211,7 +211,7 @@ export class WriteableCoMap<
     delete(key: MapK<M>, privacy: "private" | "trusting" = "private"): void {
         this.coValue.makeTransaction([
             {
-                op: "delete",
+                op: "del",
                 key,
             },
         ], privacy);

package/src/crypto.test.ts

@@ -20,6 +20,7 @@ import { x25519 } from "@noble/curves/ed25519";
 import { xsalsa20_poly1305 } from "@noble/ciphers/salsa";
 import { blake3 } from "@noble/hashes/blake3";
 import stableStringify from "fast-json-stable-stringify";
+import { SessionID } from './ids.js';
 
 test("Signatures round-trip and use stable stringify", () => {
     const data = { b: "world", a: "hello" };
@@ -49,7 +50,7 @@ test("encrypting round-trips, but invalid receiver can't unseal", () => {
 
     const nOnceMaterial = {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     } as const;
 
     const sealed = seal(
@@ -101,22 +102,22 @@ test("Encryption for transactions round-trips", () => {
 
     const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
     const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
     const decrypted1 = decryptForTransaction(encrypted1, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
     const decrypted2 =  decryptForTransaction(encrypted2, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
     expect([decrypted1, decrypted2]).toEqual([{ a: "hello" }, { b: "world" }]);
@@ -128,22 +129,22 @@ test("Encryption for transactions doesn't decrypt with a wrong key", () => {
 
     const encrypted1 =  encryptForTransaction({ a: "hello" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
     const encrypted2 = encryptForTransaction({ b: "world" }, secret, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
     const decrypted1 = decryptForTransaction(encrypted1, secret2, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 0 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 0 },
     });
 
     const decrypted2 =  decryptForTransaction(encrypted2, secret2, {
         in: "co_zTEST",
-        tx: { sessionID: "co_zTEST_session_zTEST", txIndex: 1 },
+        tx: { sessionID: "co_zTEST_session_zTEST" as SessionID, txIndex: 1 },
     });
 
     expect([decrypted1, decrypted2]).toEqual([undefined, undefined]);

package/src/index.ts

@@ -14,6 +14,7 @@ import {
 import { connectedPeers } from "./streamUtils.js";
 import { AnonymousControlledAccount, ControlledAccount } from "./account.js";
 import { rawCoIDtoBytes, rawCoIDfromBytes } from "./ids.js";
+import { Team, expectTeamContent } from "./team.js"
 
 import type { SessionID, AgentID } from "./ids.js";
 import type { CoID, ContentType } from "./contentType.js";
@@ -26,6 +27,7 @@ import type {
     ProfileContent,
     Profile,
 } from "./account.js";
+import type { InviteSecret } from "./team.js";
 
 type Value = JsonValue | ContentType;
 
@@ -42,6 +44,7 @@ export const cojsonInternals = {
     agentSecretFromSecretSeed,
     secretSeedLength,
     shortHashLength,
+    expectTeamContent
 };
 
 export {
@@ -50,6 +53,7 @@ export {
     CoMap,
     AnonymousControlledAccount,
     ControlledAccount,
+    Team
 };
 
 export type {
@@ -66,6 +70,7 @@ export type {
     AccountContent,
     Profile,
     ProfileContent,
+    InviteSecret
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace

package/src/node.ts

@@ -1,5 +1,6 @@
 import {
     AgentSecret,
+    agentSecretFromSecretSeed,
     createdNowUnique,
     getAgentID,
     getAgentSealerID,
@@ -9,7 +10,13 @@ import {
     seal,
 } from "./crypto.js";
 import { CoValue, CoValueHeader, newRandomSessionID } from "./coValue.js";
-import { Team, TeamContent, expectTeamContent } from "./permissions.js";
+import {
+    InviteSecret,
+    Team,
+    TeamContent,
+    expectTeamContent,
+    secretSeedFromInviteSecret,
+} from "./team.js";
 import { Peer, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
 import { CoID, ContentType } from "./contentType.js";
@@ -43,7 +50,10 @@ export class LocalNode {
         this.ownSessionID = ownSessionID;
     }
 
-    static withNewlyCreatedAccount(name: string, initialAgentSecret = newRandomAgentSecret()): {
+    static withNewlyCreatedAccount(
+        name: string,
+        initialAgentSecret = newRandomAgentSecret()
+    ): {
         node: LocalNode;
         accountID: AccountID;
         accountSecret: AgentSecret;
@@ -70,8 +80,16 @@ export class LocalNode {
         };
     }
 
-    static async withLoadedAccount(accountID: AccountID, accountSecret: AgentSecret, sessionID: SessionID, peersToLoadFrom: Peer[]): Promise<LocalNode> {
-        const loadingNode = new LocalNode(new AnonymousControlledAccount(accountSecret), newRandomSessionID(accountID));
+    static async withLoadedAccount(
+        accountID: AccountID,
+        accountSecret: AgentSecret,
+        sessionID: SessionID,
+        peersToLoadFrom: Peer[]
+    ): Promise<LocalNode> {
+        const loadingNode = new LocalNode(
+            new AnonymousControlledAccount(accountSecret),
+            newRandomSessionID(accountID)
+        );
 
         const accountPromise = loadingNode.load(accountID);
 
@@ -82,7 +100,10 @@ export class LocalNode {
         const account = await accountPromise;
 
         // since this is all synchronous, we can just swap out nodes for the SyncManager
-        const node = loadingNode.testWithDifferentAccount(new ControlledAccount(accountSecret, account, loadingNode), sessionID);
+        const node = loadingNode.testWithDifferentAccount(
+            new ControlledAccount(accountSecret, account, loadingNode),
+            sessionID
+        );
         node.sync = loadingNode.sync;
         node.sync.local = node;
 
@@ -124,7 +145,81 @@ export class LocalNode {
         if (!profileID) {
             throw new Error(`Account ${id} has no profile`);
         }
-        return (await this.loadCoValue(profileID)).getCurrentContent() as Profile;
+        return (
+            await this.loadCoValue(profileID)
+        ).getCurrentContent() as Profile;
+    }
+
+    async acceptInvite<T extends ContentType>(
+        teamOrOwnedValueID: CoID<T>,
+        inviteSecret: InviteSecret
+    ): Promise<void> {
+        const teamOrOwnedValue = await this.load(teamOrOwnedValueID);
+
+        if (teamOrOwnedValue.coValue.header.ruleset.type === "ownedByTeam") {
+            return this.acceptInvite(
+                teamOrOwnedValue.coValue.header.ruleset.team as CoID<
+                    CoMap<TeamContent>
+                >,
+                inviteSecret
+            );
+        } else if (teamOrOwnedValue.coValue.header.ruleset.type !== "team") {
+            throw new Error("Can only accept invites to teams");
+        }
+
+        const team = new Team(expectTeamContent(teamOrOwnedValue), this);
+
+        const inviteAgentSecret = agentSecretFromSecretSeed(
+            secretSeedFromInviteSecret(inviteSecret)
+        );
+        const inviteAgentID = getAgentID(inviteAgentSecret);
+
+        const invitationRole = await new Promise((resolve, reject) => {
+            team.teamMap.subscribe((teamMap) => {
+                const role = teamMap.get(inviteAgentID);
+                if (role) {
+                    resolve(role);
+                }
+            });
+            setTimeout(
+                () =>
+                    reject(
+                        new Error("Couldn't find invitation before timeout")
+                    ),
+                1000
+            );
+        });
+
+        if (!invitationRole) {
+            throw new Error("No invitation found");
+        }
+
+        const existingRole = team.teamMap.get(this.account.id);
+
+        if (
+            existingRole === "admin" ||
+            (existingRole === "writer" && invitationRole === "reader")
+        ) {
+            console.debug("Not accepting invite that would downgrade role");
+            return;
+        }
+
+        const teamAsInvite = team.testWithDifferentAccount(
+            new AnonymousControlledAccount(inviteAgentSecret),
+            newRandomSessionID(inviteAgentID)
+        );
+
+        teamAsInvite.addMember(
+            this.account.id,
+            invitationRole === "adminInvite"
+                ? "admin"
+                : invitationRole === "writerInvite"
+                ? "writer"
+                : "reader"
+        );
+
+        team.teamMap.coValue._sessions = teamAsInvite.teamMap.coValue.sessions;
+        team.teamMap.coValue._cachedContent = undefined;
     }
 
     expectCoValueLoaded(id: RawCoID, expectation?: string): CoValue {
@@ -146,7 +241,9 @@ export class LocalNode {
 
     expectProfileLoaded(id: AccountID, expectation?: string): Profile {
         const account = this.expectCoValueLoaded(id, expectation);
-        const profileID = expectTeamContent(account.getCurrentContent()).get("profile");
+        const profileID = expectTeamContent(account.getCurrentContent()).get(
+            "profile"
+        );
         if (!profileID) {
             throw new Error(
                 `${
@@ -154,10 +251,16 @@ export class LocalNode {
                 }Account ${id} has no profile`
             );
         }
-        return this.expectCoValueLoaded(profileID, expectation).getCurrentContent() as Profile;
+        return this.expectCoValueLoaded(
+            profileID,
+            expectation
+        ).getCurrentContent() as Profile;
     }
 
-    createAccount(name: string, agentSecret = newRandomAgentSecret()): ControlledAccount {
+    createAccount(
+        name: string,
+        agentSecret = newRandomAgentSecret()
+    ): ControlledAccount {
         const account = this.createCoValue(
             accountHeaderForInitialAgentSecret(agentSecret)
         ).testWithDifferentAccount(
@@ -165,7 +268,10 @@ export class LocalNode {
             newRandomSessionID(getAgentID(agentSecret))
         );
 
-        const accountAsTeam = new Team(expectTeamContent(account.getCurrentContent()), account.node);
+        const accountAsTeam = new Team(
+            expectTeamContent(account.getCurrentContent()),
+            account.node
+        );
 
         accountAsTeam.teamMap.edit((editable) => {
             editable.set(getAgentID(agentSecret), "admin", "trusting");
@@ -195,7 +301,9 @@ export class LocalNode {
             account.node
         );
 
-        const profile = accountAsTeam.createMap<ProfileContent, ProfileMeta>({ type: "profile" });
+        const profile = accountAsTeam.createMap<ProfileContent, ProfileMeta>({
+            type: "profile",
+        });
 
         profile.edit((editable) => {
             editable.set("name", name, "trusting");
@@ -205,6 +313,11 @@ export class LocalNode {
             editable.set("profile", profile.id, "trusting");
         });
 
+        const accountOnThisNode = this.expectCoValueLoaded(account.id);
+
+        accountOnThisNode._sessions = {...accountAsTeam.teamMap.coValue.sessions};
+        accountOnThisNode._cachedContent = undefined;
+
         return controlledAccount;
     }
 
@@ -276,24 +389,36 @@ export class LocalNode {
     ): LocalNode {
         const newNode = new LocalNode(account, ownSessionID);
 
-        newNode.coValues = Object.fromEntries(
-            Object.entries(this.coValues)
-                .map(([id, entry]) => {
-                    if (entry.state === "loading") {
-                        return undefined;
-                    }
+        const coValuesToCopy = Object.entries(this.coValues);
 
-                    const newCoValue = new CoValue(
-                        entry.coValue.header,
-                        newNode
-                    );
+        while (coValuesToCopy.length > 0) {
+            const [coValueID, entry] =
+                coValuesToCopy[coValuesToCopy.length - 1]!;
 
-                    newCoValue.sessions = entry.coValue.sessions;
+            if (entry.state === "loading") {
+                coValuesToCopy.pop();
+                continue;
+            } else {
+                const allDepsCopied = entry.coValue
+                    .getDependedOnCoValues()
+                    .every((dep) => newNode.coValues[dep]?.state === "loaded");
 
-                    return [id, { state: "loaded", coValue: newCoValue }];
-                })
-                .filter((x): x is Exclude<typeof x, undefined> => !!x)
-        );
+                if (!allDepsCopied) {
+                    // move to end of queue
+                    coValuesToCopy.unshift(coValuesToCopy.pop()!);
+                    continue;
+                }
+
+                const newCoValue = new CoValue(entry.coValue.header, newNode, {...entry.coValue.sessions});
+
+                newNode.coValues[coValueID as RawCoID] = {
+                    state: "loaded",
+                    coValue: newCoValue,
+                };
+
+                coValuesToCopy.pop();
+            }
+        }
 
         return newNode;
     }