cojson 0.0.11 → 0.0.13

package/src/sync.ts

@@ -8,43 +8,43 @@ import {
     WritableStream,
     WritableStreamDefaultWriter,
 } from "isomorphic-streams";
-import { RawCoValueID, SessionID } from "./ids.js";
+import { RawCoID, SessionID } from "./ids.js";
 
 export type CoValueKnownState = {
-    coValueID: RawCoValueID;
+    id: RawCoID;
     header: boolean;
     sessions: { [sessionID: SessionID]: number };
 };
 
-export function emptyKnownState(coValueID: RawCoValueID): CoValueKnownState {
+export function emptyKnownState(id: RawCoID): CoValueKnownState {
     return {
-        coValueID,
+        id,
         header: false,
         sessions: {},
     };
 }
 
 export type SyncMessage =
-    | SubscribeMessage
-    | TellKnownStateMessage
+    | LoadMessage
+    | KnownStateMessage
     | NewContentMessage
-    | WrongAssumedKnownStateMessage
-    | UnsubscribeMessage;
+    | DoneMessage;
 
-export type SubscribeMessage = {
-    action: "subscribe";
+export type LoadMessage = {
+    action: "load";
 } & CoValueKnownState;
 
-export type TellKnownStateMessage = {
-    action: "tellKnownState";
-    asDependencyOf?: RawCoValueID;
+export type KnownStateMessage = {
+    action: "known";
+    asDependencyOf?: RawCoID;
+    isCorrection?: boolean;
 } & CoValueKnownState;
 
 export type NewContentMessage = {
-    action: "newContent";
-    coValueID: RawCoValueID;
+    action: "content";
+    id: RawCoID;
     header?: CoValueHeader;
-    newContent: {
+    new: {
         [sessionID: SessionID]: SessionNewContent;
     };
 };
@@ -52,18 +52,11 @@ export type NewContentMessage = {
 export type SessionNewContent = {
     after: number;
     newTransactions: Transaction[];
-    // TODO: is lastHash needed here?
-    lastHash: Hash;
     lastSignature: Signature;
 };
-
-export type WrongAssumedKnownStateMessage = {
-    action: "wrongAssumedKnownState";
-} & CoValueKnownState;
-
-export type UnsubscribeMessage = {
-    action: "unsubscribe";
-    coValueID: RawCoValueID;
+export type DoneMessage = {
+    action: "done";
+    id: RawCoID;
 };
 
 export type PeerID = string;
@@ -77,8 +70,8 @@ export interface Peer {
 
 export interface PeerState {
     id: PeerID;
-    optimisticKnownStates: { [coValueID: RawCoValueID]: CoValueKnownState };
-    toldKnownState: Set<RawCoValueID>;
+    optimisticKnownStates: { [id: RawCoID]: CoValueKnownState };
+    toldKnownState: Set<RawCoID>;
     incoming: ReadableStream<SyncMessage>;
     outgoing: WritableStreamDefaultWriter<SyncMessage>;
     role: "peer" | "server" | "client";
@@ -103,7 +96,7 @@ export function combinedKnownStates(
     }
 
     return {
-        coValueID: stateA.coValueID,
+        id: stateA.id,
         header: stateA.header || stateB.header,
         sessions: sessionStates,
     };
@@ -117,12 +110,12 @@ export class SyncManager {
         this.local = local;
     }
 
-    loadFromPeers(id: RawCoValueID) {
+    loadFromPeers(id: RawCoID) {
         for (const peer of Object.values(this.peers)) {
             peer.outgoing
                 .write({
-                    action: "subscribe",
-                    coValueID: id,
+                    action: "load",
+                    id: id,
                     header: false,
                     sessions: {},
                 })
@@ -135,15 +128,17 @@ export class SyncManager {
     async handleSyncMessage(msg: SyncMessage, peer: PeerState) {
         // TODO: validate
         switch (msg.action) {
-            case "subscribe":
-                return await this.handleSubscribe(msg, peer);
-            case "tellKnownState":
-                return await this.handleTellKnownState(msg, peer);
-            case "newContent":
+            case "load":
+                return await this.handleLoad(msg, peer);
+            case "known":
+                if (msg.isCorrection) {
+                    return await this.handleCorrection(msg, peer);
+                } else {
+                    return await this.handleKnownState(msg, peer);
+                }
+            case "content":
                 return await this.handleNewContent(msg, peer);
-            case "wrongAssumedKnownState":
-                return await this.handleWrongAssumedKnownState(msg, peer);
-            case "unsubscribe":
+            case "done":
                 return await this.handleUnsubscribe(msg);
             default:
                 throw new Error(
@@ -155,10 +150,10 @@ export class SyncManager {
     }
 
     async subscribeToIncludingDependencies(
-        coValueID: RawCoValueID,
+        id: RawCoID,
         peer: PeerState
     ) {
-        const entry = this.local.coValues[coValueID];
+        const entry = this.local.coValues[id];
 
         if (!entry) {
             throw new Error(
@@ -168,8 +163,8 @@ export class SyncManager {
 
         if (entry.state === "loading") {
             await this.trySendToPeer(peer, {
-                action: "subscribe",
-                coValueID,
+                action: "load",
+                id,
                 header: false,
                 sessions: {},
             });
@@ -178,64 +173,64 @@ export class SyncManager {
 
         const coValue = entry.coValue;
 
-        for (const coValueID of coValue.getDependedOnCoValues()) {
-            await this.subscribeToIncludingDependencies(coValueID, peer);
+        for (const id of coValue.getDependedOnCoValues()) {
+            await this.subscribeToIncludingDependencies(id, peer);
         }
 
-        if (!peer.toldKnownState.has(coValueID)) {
-            peer.toldKnownState.add(coValueID);
+        if (!peer.toldKnownState.has(id)) {
+            peer.toldKnownState.add(id);
             await this.trySendToPeer(peer, {
-                action: "subscribe",
+                action: "load",
                 ...coValue.knownState(),
             });
         }
     }
 
     async tellUntoldKnownStateIncludingDependencies(
-        coValueID: RawCoValueID,
+        id: RawCoID,
         peer: PeerState,
-        asDependencyOf?: RawCoValueID
+        asDependencyOf?: RawCoID
     ) {
-        const coValue = this.local.expectCoValueLoaded(coValueID);
+        const coValue = this.local.expectCoValueLoaded(id);
 
-        for (const dependentCoValueID of coValue.getDependedOnCoValues()) {
+        for (const dependentCoID of coValue.getDependedOnCoValues()) {
             await this.tellUntoldKnownStateIncludingDependencies(
-                dependentCoValueID,
+                dependentCoID,
                 peer,
-                asDependencyOf || coValueID
+                asDependencyOf || id
             );
         }
 
-        if (!peer.toldKnownState.has(coValueID)) {
+        if (!peer.toldKnownState.has(id)) {
             await this.trySendToPeer(peer, {
-                action: "tellKnownState",
+                action: "known",
                 asDependencyOf,
                 ...coValue.knownState(),
             });
 
-            peer.toldKnownState.add(coValueID);
+            peer.toldKnownState.add(id);
         }
     }
 
     async sendNewContentIncludingDependencies(
-        coValueID: RawCoValueID,
+        id: RawCoID,
         peer: PeerState
     ) {
-        const coValue = this.local.expectCoValueLoaded(coValueID);
+        const coValue = this.local.expectCoValueLoaded(id);
 
-        for (const coValueID of coValue.getDependedOnCoValues()) {
-            await this.sendNewContentIncludingDependencies(coValueID, peer);
+        for (const id of coValue.getDependedOnCoValues()) {
+            await this.sendNewContentIncludingDependencies(id, peer);
         }
 
         const newContent = coValue.newContentSince(
-            peer.optimisticKnownStates[coValueID]
+            peer.optimisticKnownStates[id]
         );
 
         if (newContent) {
             await this.trySendToPeer(peer, newContent);
-            peer.optimisticKnownStates[coValueID] = combinedKnownStates(
-                peer.optimisticKnownStates[coValueID] ||
-                    emptyKnownState(coValueID),
+            peer.optimisticKnownStates[id] = combinedKnownStates(
+                peer.optimisticKnownStates[id] ||
+                    emptyKnownState(id),
                 coValue.knownState()
             );
         }
@@ -256,11 +251,11 @@ export class SyncManager {
             const initialSync = async () => {
                 for (const id of Object.keys(
                     this.local.coValues
-                ) as RawCoValueID[]) {
+                ) as RawCoID[]) {
                     await this.subscribeToIncludingDependencies(id, peerState);
 
                     peerState.optimisticKnownStates[id] = {
-                        coValueID: id,
+                        id: id,
                         header: false,
                         sessions: {},
                     };
@@ -295,20 +290,20 @@ export class SyncManager {
         });
     }
 
-    async handleSubscribe(msg: SubscribeMessage, peer: PeerState) {
-        const entry = this.local.coValues[msg.coValueID];
+    async handleLoad(msg: LoadMessage, peer: PeerState) {
+        const entry = this.local.coValues[msg.id];
 
         if (!entry || entry.state === "loading") {
             if (!entry) {
-                this.local.coValues[msg.coValueID] = newLoadingState();
+                this.local.coValues[msg.id] = newLoadingState();
             }
 
-            peer.optimisticKnownStates[msg.coValueID] = knownStateIn(msg);
-            peer.toldKnownState.add(msg.coValueID);
+            peer.optimisticKnownStates[msg.id] = knownStateIn(msg);
+            peer.toldKnownState.add(msg.id);
 
             await this.trySendToPeer(peer, {
-                action: "tellKnownState",
-                coValueID: msg.coValueID,
+                action: "known",
+                id: msg.id,
                 header: false,
                 sessions: {},
             });
@@ -316,22 +311,22 @@ export class SyncManager {
             return;
         }
 
-        peer.optimisticKnownStates[msg.coValueID] = knownStateIn(msg);
+        peer.optimisticKnownStates[msg.id] = knownStateIn(msg);
 
         await this.tellUntoldKnownStateIncludingDependencies(
-            msg.coValueID,
+            msg.id,
             peer
         );
 
-        await this.sendNewContentIncludingDependencies(msg.coValueID, peer);
+        await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
 
-    async handleTellKnownState(msg: TellKnownStateMessage, peer: PeerState) {
-        let entry = this.local.coValues[msg.coValueID];
+    async handleKnownState(msg: KnownStateMessage, peer: PeerState) {
+        let entry = this.local.coValues[msg.id];
 
-        peer.optimisticKnownStates[msg.coValueID] = combinedKnownStates(
-            peer.optimisticKnownStates[msg.coValueID] ||
-                emptyKnownState(msg.coValueID),
+        peer.optimisticKnownStates[msg.id] = combinedKnownStates(
+            peer.optimisticKnownStates[msg.id] ||
+                emptyKnownState(msg.id),
             knownStateIn(msg)
         );
 
@@ -340,7 +335,7 @@ export class SyncManager {
                 if (this.local.coValues[msg.asDependencyOf]) {
                     entry = newLoadingState();
 
-                    this.local.coValues[msg.coValueID] = entry;
+                    this.local.coValues[msg.id] = entry;
                 } else {
                     throw new Error(
                         "Expected coValue dependency entry to be created, missing subscribe?"
@@ -358,14 +353,14 @@ export class SyncManager {
         }
 
         await this.tellUntoldKnownStateIncludingDependencies(
-            msg.coValueID,
+            msg.id,
             peer
         );
-        await this.sendNewContentIncludingDependencies(msg.coValueID, peer);
+        await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
 
     async handleNewContent(msg: NewContentMessage, peer: PeerState) {
-        let entry = this.local.coValues[msg.coValueID];
+        let entry = this.local.coValues[msg.id];
 
         if (!entry) {
             throw new Error(
@@ -376,7 +371,7 @@ export class SyncManager {
         let resolveAfterDone: ((coValue: CoValue) => void) | undefined;
 
         const peerOptimisticKnownState =
-            peer.optimisticKnownStates[msg.coValueID];
+            peer.optimisticKnownStates[msg.id];
 
         if (!peerOptimisticKnownState) {
             throw new Error(
@@ -400,7 +395,7 @@ export class SyncManager {
                 coValue: coValue,
             };
 
-            this.local.coValues[msg.coValueID] = entry;
+            this.local.coValues[msg.id] = entry;
         }
 
         const coValue = entry.coValue;
@@ -408,7 +403,7 @@ export class SyncManager {
         let invalidStateAssumed = false;
 
         for (const [sessionID, newContentForSession] of Object.entries(
-            msg.newContent
+            msg.new
         ) as [SessionID, SessionNewContent][]) {
             const ourKnownTxIdx =
                 coValue.sessions[sessionID]?.transactions.length;
@@ -429,7 +424,7 @@ export class SyncManager {
             const success = coValue.tryAddTransactions(
                 sessionID,
                 newTransactions,
-                newContentForSession.lastHash,
+                undefined,
                 newContentForSession.lastSignature
             );
 
@@ -451,19 +446,20 @@ export class SyncManager {
 
         if (invalidStateAssumed) {
             await this.trySendToPeer(peer, {
-                action: "wrongAssumedKnownState",
+                action: "known",
+                isCorrection: true,
                 ...coValue.knownState(),
             });
         }
     }
 
-    async handleWrongAssumedKnownState(
-        msg: WrongAssumedKnownStateMessage,
+    async handleCorrection(
+        msg: KnownStateMessage,
         peer: PeerState
     ) {
-        const coValue = this.local.expectCoValueLoaded(msg.coValueID);
+        const coValue = this.local.expectCoValueLoaded(msg.id);
 
-        peer.optimisticKnownStates[msg.coValueID] = combinedKnownStates(
+        peer.optimisticKnownStates[msg.id] = combinedKnownStates(
             msg,
             coValue.knownState()
         );
@@ -475,7 +471,7 @@ export class SyncManager {
         }
     }
 
-    handleUnsubscribe(_msg: UnsubscribeMessage) {
+    handleUnsubscribe(_msg: DoneMessage) {
         throw new Error("Method not implemented.");
     }
 
@@ -505,12 +501,11 @@ export class SyncManager {
 
 function knownStateIn(
     msg:
-        | SubscribeMessage
-        | TellKnownStateMessage
-        | WrongAssumedKnownStateMessage
+        | LoadMessage
+        | KnownStateMessage
 ) {
     return {
-        coValueID: msg.coValueID,
+        id: msg.id,
         header: msg.header,
         sessions: msg.sessions,
     };

package/src/testUtils.ts

@@ -0,0 +1,229 @@
+import { AgentSecret, createdNowUnique, getAgentID, newRandomAgentSecret  } from "./crypto.js";
+import { newRandomSessionID } from "./coValue.js";
+import { LocalNode } from "./node.js";
+import { expectTeamContent } from "./permissions.js";
+import { AnonymousControlledAccount } from "./account.js";
+import { SessionID } from "./ids.js";
+import { ReadableStream, TransformStream, WritableStream } from "isomorphic-streams";
+import { Peer, PeerID, SyncMessage } from "./sync.js";
+
+export function randomAnonymousAccountAndSessionID(): [AnonymousControlledAccount, SessionID] {
+    const agentSecret = newRandomAgentSecret();
+
+    const sessionID = newRandomSessionID(getAgentID(agentSecret));
+
+    return [new AnonymousControlledAccount(agentSecret), sessionID];
+}
+
+export function newTeam() {
+    const [admin, sessionID] = randomAnonymousAccountAndSessionID();
+
+    const node = new LocalNode(admin, sessionID);
+
+    const team = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "team", initialAdmin: admin.id },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const teamContent = expectTeamContent(team.getCurrentContent());
+
+    teamContent.edit((editable) => {
+        editable.set(admin.id, "admin", "trusting");
+        expect(editable.get(admin.id)).toEqual("admin");
+    });
+
+    return { node, team, admin };
+}
+
+export function teamWithTwoAdmins() {
+    const { team, admin, node } = newTeam();
+
+    const otherAdmin = node.createAccount("otherAdmin");
+
+    let content = expectTeamContent(team.getCurrentContent());
+
+    content.edit((editable) => {
+        editable.set(otherAdmin.id, "admin", "trusting");
+        expect(editable.get(otherAdmin.id)).toEqual("admin");
+    });
+
+    content = expectTeamContent(team.getCurrentContent());
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.get(otherAdmin.id)).toEqual("admin");
+    return { team, admin, otherAdmin, node };
+}
+
+export function newTeamHighLevel() {
+    const [admin, sessionID] = randomAnonymousAccountAndSessionID();
+
+
+    const node = new LocalNode(admin, sessionID);
+
+    const team = node.createTeam();
+
+    return { admin, node, team };
+}
+
+export function teamWithTwoAdminsHighLevel() {
+    const { admin, node, team } = newTeamHighLevel();
+
+    const otherAdmin = node.createAccount("otherAdmin");
+
+    team.addMember(otherAdmin.id, "admin");
+
+    return { admin, node, team, otherAdmin };
+}
+
+export function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
+    const queue: T[] = [];
+    let resolveNextItemReady: () => void = () => {};
+    let nextItemReady: Promise<void> = new Promise((resolve) => {
+        resolveNextItemReady = resolve;
+    });
+
+    let writerClosed = false;
+    let readerClosed = false;
+
+    const readable = new ReadableStream<T>({
+        async pull(controller) {
+            let retriesLeft = 3;
+            while (retriesLeft > 0) {
+                if (writerClosed) {
+                    controller.close();
+                    return;
+                }
+                retriesLeft--;
+                if (queue.length > 0) {
+                    controller.enqueue(queue.shift()!);
+                    if (queue.length === 0) {
+                        nextItemReady = new Promise((resolve) => {
+                            resolveNextItemReady = resolve;
+                        });
+                    }
+                    return;
+                } else {
+                    await nextItemReady;
+                }
+            }
+            throw new Error(
+                "Should only use one retry to get next item in queue."
+            );
+        },
+
+        cancel(reason) {
+            console.log("Manually closing reader");
+            readerClosed = true;
+        },
+    });
+
+    const writable = new WritableStream<T>({
+        write(chunk, controller) {
+            if (readerClosed) {
+                console.log("Reader closed, not writing chunk", chunk);
+                throw new Error("Reader closed, not writing chunk");
+            }
+            queue.push(chunk);
+            if (queue.length === 1) {
+                // make sure that await write resolves before corresponding read
+                process.nextTick(() => resolveNextItemReady());
+            }
+        },
+        abort(reason) {
+            console.log("Manually closing writer");
+            writerClosed = true;
+            resolveNextItemReady();
+            return Promise.resolve();
+        },
+    });
+
+    return [readable, writable];
+}
+
+export function shouldNotResolve<T>(
+    promise: Promise<T>,
+    ops: { timeout: number }
+): Promise<void> {
+    return new Promise((resolve, reject) => {
+        promise
+            .then((v) =>
+                reject(
+                    new Error(
+                        "Should not have resolved, but resolved to " +
+                            JSON.stringify(v)
+                    )
+                )
+            )
+            .catch(reject);
+        setTimeout(resolve, ops.timeout);
+    });
+}
+
+export function connectedPeers(
+    peer1id: PeerID,
+    peer2id: PeerID,
+    {
+        trace = false,
+        peer1role = "peer",
+        peer2role = "peer",
+    }: {
+        trace?: boolean;
+        peer1role?: Peer["role"];
+        peer2role?: Peer["role"];
+    } = {}
+): [Peer, Peer] {
+    const [inRx1, inTx1] = newStreamPair<SyncMessage>();
+    const [outRx1, outTx1] = newStreamPair<SyncMessage>();
+
+    const [inRx2, inTx2] = newStreamPair<SyncMessage>();
+    const [outRx2, outTx2] = newStreamPair<SyncMessage>();
+
+    void outRx2
+        .pipeThrough(
+            new TransformStream({
+                transform(
+                    chunk: SyncMessage,
+                    controller: { enqueue: (msg: SyncMessage) => void }
+                ) {
+                    trace && console.log(`${peer2id} -> ${peer1id}`, JSON.stringify(chunk, null, 2));
+                    controller.enqueue(chunk);
+                },
+            })
+        )
+        .pipeTo(inTx1);
+
+    void outRx1
+        .pipeThrough(
+            new TransformStream({
+                transform(
+                    chunk: SyncMessage,
+                    controller: { enqueue: (msg: SyncMessage) => void }
+                ) {
+                    trace && console.log(`${peer1id} -> ${peer2id}`, JSON.stringify(chunk, null, 2));
+                    controller.enqueue(chunk);
+                },
+            })
+        )
+        .pipeTo(inTx2);
+
+    const peer2AsPeer: Peer = {
+        id: peer2id,
+        incoming: inRx1,
+        outgoing: outTx1,
+        role: peer2role,
+    };
+
+    const peer1AsPeer: Peer = {
+        id: peer1id,
+        incoming: inRx2,
+        outgoing: outTx2,
+        role: peer1role,
+    };
+
+    return [peer1AsPeer, peer2AsPeer];
+}