cojson 0.0.7 → 0.0.8

package/dist/sync.mjs

@@ -1,318 +0,0 @@
-"use strict";
-import { CoValue } from "./coValue";
-import { newLoadingState } from "./node";
-export function emptyKnownState(coValueID) {
-  return {
-    coValueID,
-    header: false,
-    sessions: {}
-  };
-}
-export function combinedKnownStates(stateA, stateB) {
-  const sessionStates = {};
-  const allSessions = /* @__PURE__ */ new Set([
-    ...Object.keys(stateA.sessions),
-    ...Object.keys(stateB.sessions)
-  ]);
-  for (const sessionID of allSessions) {
-    const stateAValue = stateA.sessions[sessionID];
-    const stateBValue = stateB.sessions[sessionID];
-    sessionStates[sessionID] = Math.max(stateAValue || 0, stateBValue || 0);
-  }
-  return {
-    coValueID: stateA.coValueID,
-    header: stateA.header || stateB.header,
-    sessions: sessionStates
-  };
-}
-export class SyncManager {
-  peers = {};
-  local;
-  constructor(local) {
-    this.local = local;
-  }
-  loadFromPeers(id) {
-    for (const peer of Object.values(this.peers)) {
-      peer.outgoing.write({
-        action: "subscribe",
-        coValueID: id,
-        header: false,
-        sessions: {}
-      }).catch((e) => {
-        console.error("Error writing to peer", e);
-      });
-    }
-  }
-  async handleSyncMessage(msg, peer) {
-    switch (msg.action) {
-      case "subscribe":
-        return await this.handleSubscribe(msg, peer);
-      case "tellKnownState":
-        return await this.handleTellKnownState(msg, peer);
-      case "newContent":
-        return await this.handleNewContent(msg, peer);
-      case "wrongAssumedKnownState":
-        return await this.handleWrongAssumedKnownState(msg, peer);
-      case "unsubscribe":
-        return await this.handleUnsubscribe(msg);
-      default:
-        throw new Error(
-          `Unknown message type ${msg.action}`
-        );
-    }
-  }
-  async subscribeToIncludingDependencies(coValueID, peer) {
-    const coValue = this.local.expectCoValueLoaded(coValueID);
-    for (const coValueID2 of coValue.getDependedOnCoValues()) {
-      await this.subscribeToIncludingDependencies(coValueID2, peer);
-    }
-    if (!peer.toldKnownState.has(coValueID)) {
-      peer.toldKnownState.add(coValueID);
-      await peer.outgoing.write({
-        action: "subscribe",
-        ...coValue.knownState()
-      });
-    }
-  }
-  async tellUntoldKnownStateIncludingDependencies(coValueID, peer, asDependencyOf) {
-    const coValue = this.local.expectCoValueLoaded(coValueID);
-    for (const dependentCoValueID of coValue.getDependedOnCoValues()) {
-      await this.tellUntoldKnownStateIncludingDependencies(
-        dependentCoValueID,
-        peer,
-        asDependencyOf || coValueID
-      );
-    }
-    if (!peer.toldKnownState.has(coValueID)) {
-      await peer.outgoing.write({
-        action: "tellKnownState",
-        asDependencyOf,
-        ...coValue.knownState()
-      });
-      peer.toldKnownState.add(coValueID);
-    }
-  }
-  async sendNewContentIncludingDependencies(coValueID, peer) {
-    const coValue = this.local.expectCoValueLoaded(coValueID);
-    for (const coValueID2 of coValue.getDependedOnCoValues()) {
-      await this.sendNewContentIncludingDependencies(coValueID2, peer);
-    }
-    const newContent = coValue.newContentSince(
-      peer.optimisticKnownStates[coValueID]
-    );
-    if (newContent) {
-      await peer.outgoing.write(newContent);
-      peer.optimisticKnownStates[coValueID] = combinedKnownStates(
-        peer.optimisticKnownStates[coValueID] || emptyKnownState(coValueID),
-        coValue.knownState()
-      );
-    }
-  }
-  addPeer(peer) {
-    const peerState = {
-      id: peer.id,
-      optimisticKnownStates: {},
-      incoming: peer.incoming,
-      outgoing: peer.outgoing.getWriter(),
-      toldKnownState: /* @__PURE__ */ new Set(),
-      role: peer.role
-    };
-    this.peers[peer.id] = peerState;
-    if (peer.role === "server") {
-      const initialSync = async () => {
-        for (const entry of Object.values(this.local.coValues)) {
-          if (entry.state === "loading") {
-            continue;
-          }
-          await this.subscribeToIncludingDependencies(
-            entry.coValue.id,
-            peerState
-          );
-          peerState.optimisticKnownStates[entry.coValue.id] = {
-            coValueID: entry.coValue.id,
-            header: false,
-            sessions: {}
-          };
-        }
-      };
-      void initialSync();
-    }
-    const readIncoming = async () => {
-      for await (const msg of peerState.incoming) {
-        try {
-          await this.handleSyncMessage(msg, peerState);
-        } catch (e) {
-          console.error(
-            `Error reading from peer ${peer.id}`,
-            JSON.stringify(msg),
-            e
-          );
-        }
-      }
-    };
-    void readIncoming();
-  }
-  async handleSubscribe(msg, peer) {
-    const entry = this.local.coValues[msg.coValueID];
-    if (!entry || entry.state === "loading") {
-      if (!entry) {
-        this.local.coValues[msg.coValueID] = newLoadingState();
-      }
-      peer.optimisticKnownStates[msg.coValueID] = knownStateIn(msg);
-      peer.toldKnownState.add(msg.coValueID);
-      await peer.outgoing.write({
-        action: "tellKnownState",
-        coValueID: msg.coValueID,
-        header: false,
-        sessions: {}
-      });
-      return;
-    }
-    peer.optimisticKnownStates[msg.coValueID] = knownStateIn(msg);
-    await this.tellUntoldKnownStateIncludingDependencies(
-      msg.coValueID,
-      peer
-    );
-    await this.sendNewContentIncludingDependencies(msg.coValueID, peer);
-  }
-  async handleTellKnownState(msg, peer) {
-    let entry = this.local.coValues[msg.coValueID];
-    peer.optimisticKnownStates[msg.coValueID] = combinedKnownStates(
-      peer.optimisticKnownStates[msg.coValueID] || emptyKnownState(msg.coValueID),
-      knownStateIn(msg)
-    );
-    if (!entry) {
-      if (msg.asDependencyOf) {
-        if (this.local.coValues[msg.asDependencyOf]) {
-          entry = newLoadingState();
-          this.local.coValues[msg.coValueID] = entry;
-        } else {
-          throw new Error(
-            "Expected coValue dependency entry to be created, missing subscribe?"
-          );
-        }
-      } else {
-        throw new Error(
-          "Expected coValue entry to be created, missing subscribe?"
-        );
-      }
-    }
-    if (entry.state === "loading") {
-      return [];
-    }
-    await this.tellUntoldKnownStateIncludingDependencies(
-      msg.coValueID,
-      peer
-    );
-    await this.sendNewContentIncludingDependencies(msg.coValueID, peer);
-  }
-  async handleNewContent(msg, peer) {
-    var _a;
-    let entry = this.local.coValues[msg.coValueID];
-    if (!entry) {
-      throw new Error(
-        "Expected coValue entry to be created, missing subscribe?"
-      );
-    }
-    let resolveAfterDone;
-    const peerOptimisticKnownState = peer.optimisticKnownStates[msg.coValueID];
-    if (!peerOptimisticKnownState) {
-      throw new Error(
-        "Expected optimisticKnownState to be set for coValue we receive new content for"
-      );
-    }
-    if (entry.state === "loading") {
-      if (!msg.header) {
-        throw new Error("Expected header to be sent in first message");
-      }
-      peerOptimisticKnownState.header = true;
-      const coValue2 = new CoValue(msg.header, this.local);
-      resolveAfterDone = entry.resolve;
-      entry = {
-        state: "loaded",
-        coValue: coValue2
-      };
-      this.local.coValues[msg.coValueID] = entry;
-    }
-    const coValue = entry.coValue;
-    let invalidStateAssumed = false;
-    for (const [sessionID, newContentForSession] of Object.entries(
-      msg.newContent
-    )) {
-      const ourKnownTxIdx = (_a = coValue.sessions[sessionID]) == null ? void 0 : _a.transactions.length;
-      const theirFirstNewTxIdx = newContentForSession.after;
-      if ((ourKnownTxIdx || 0) < theirFirstNewTxIdx) {
-        invalidStateAssumed = true;
-        continue;
-      }
-      const alreadyKnownOffset = ourKnownTxIdx ? ourKnownTxIdx - theirFirstNewTxIdx : 0;
-      const newTransactions = newContentForSession.newTransactions.slice(alreadyKnownOffset);
-      const success = coValue.tryAddTransactions(
-        sessionID,
-        newTransactions,
-        newContentForSession.lastHash,
-        newContentForSession.lastSignature
-      );
-      if (!success) {
-        console.error("Failed to add transactions", newTransactions);
-        continue;
-      }
-      peerOptimisticKnownState.sessions[sessionID] = newContentForSession.after + newContentForSession.newTransactions.length;
-    }
-    if (resolveAfterDone) {
-      resolveAfterDone(coValue);
-    }
-    await this.syncCoValue(coValue);
-    if (invalidStateAssumed) {
-      await peer.outgoing.write({
-        action: "wrongAssumedKnownState",
-        ...coValue.knownState()
-      });
-    }
-  }
-  async handleWrongAssumedKnownState(msg, peer) {
-    const coValue = this.local.expectCoValueLoaded(msg.coValueID);
-    peer.optimisticKnownStates[msg.coValueID] = combinedKnownStates(
-      msg,
-      coValue.knownState()
-    );
-    const newContent = coValue.newContentSince(msg);
-    if (newContent) {
-      await peer.outgoing.write(newContent);
-    }
-  }
-  handleUnsubscribe(_msg) {
-    throw new Error("Method not implemented.");
-  }
-  async syncCoValue(coValue) {
-    for (const peer of Object.values(this.peers)) {
-      const optimisticKnownState = peer.optimisticKnownStates[coValue.id];
-      if (optimisticKnownState) {
-        await this.tellUntoldKnownStateIncludingDependencies(
-          coValue.id,
-          peer
-        );
-        await this.sendNewContentIncludingDependencies(
-          coValue.id,
-          peer
-        );
-      } else if (peer.role === "server") {
-        await this.subscribeToIncludingDependencies(
-          coValue.id,
-          peer
-        );
-        await this.sendNewContentIncludingDependencies(
-          coValue.id,
-          peer
-        );
-      }
-    }
-  }
-}
-function knownStateIn(msg) {
-  return {
-    coValueID: msg.coValueID,
-    header: msg.header,
-    sessions: msg.sessions
-  };
-}