cojson 0.13.11 → 0.13.13

package/src/localNode.ts

@@ -126,7 +126,7 @@ export class LocalNode {
     );
 
     nodeWithAccount.account = controlledAccount;
-    nodeWithAccount.coValuesStore.setAsAvailable(
+    nodeWithAccount.coValuesStore.internalMarkMagicallyAvailable(
       controlledAccount.id,
       controlledAccount.core,
     );
@@ -139,10 +139,8 @@ export class LocalNode {
     // we shouldn't need this, but it fixes account data not syncing for new accounts
     function syncAllCoValuesAfterCreateAccount() {
       for (const coValueEntry of nodeWithAccount.coValuesStore.getValues()) {
-        if (coValueEntry.state.type === "available") {
-          void nodeWithAccount.syncManager.syncCoValue(
-            coValueEntry.state.coValue,
-          );
+        if (coValueEntry.isAvailable()) {
+          void nodeWithAccount.syncManager.syncCoValue(coValueEntry.core);
         }
       }
     }
@@ -208,7 +206,10 @@ export class LocalNode {
       node.syncManager.local = node;
 
       controlledAccount.core.node = node;
-      node.coValuesStore.setAsAvailable(accountID, controlledAccount.core);
+      node.coValuesStore.internalMarkMagicallyAvailable(
+        accountID,
+        controlledAccount.core,
+      );
       controlledAccount.core._cachedContent = undefined;
 
       const profileID = account.get("profile");
@@ -245,7 +246,7 @@ export class LocalNode {
     }
 
     const coValue = new CoValueCore(header, this);
-    this.coValuesStore.setAsAvailable(coValue.id, coValue);
+    this.coValuesStore.internalMarkMagicallyAvailable(coValue.id, coValue);
 
     void this.syncManager.syncCoValue(coValue);
 
@@ -265,10 +266,17 @@ export class LocalNode {
 
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type === "unknown" || entry.state.type === "unavailable") {
+    if (
+      entry.highLevelState === "unknown" ||
+      entry.highLevelState === "unavailable"
+    ) {
       const peers =
         this.syncManager.getServerAndStoragePeers(skipLoadingFromPeer);
 
+      if (peers.length === 0) {
+        return "unavailable";
+      }
+
       await entry.loadFromPeers(peers).catch((e) => {
         logger.error("Error loading from peers", {
           id,
@@ -309,8 +317,8 @@ export class LocalNode {
   getLoaded<T extends RawCoValue>(id: CoID<T>): T | undefined {
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type === "available") {
-      return entry.state.coValue.getCurrentContent() as T;
+    if (entry.isAvailable()) {
+      return entry.core.getCurrentContent() as T;
     }
 
     return undefined;
@@ -439,12 +447,12 @@ export class LocalNode {
   expectCoValueLoaded(id: RawCoID, expectation?: string): CoValueCore {
     const entry = this.coValuesStore.get(id);
 
-    if (entry.state.type !== "available") {
+    if (!entry.isAvailable()) {
       throw new Error(
-        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded. Current state: ${entry.state.type}`,
+        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded. Current state: ${JSON.stringify(entry)}`,
       );
     }
-    return entry.state.coValue;
+    return entry.core;
   }
 
   /** @internal */
@@ -638,15 +646,13 @@ export class LocalNode {
     while (coValuesToCopy.length > 0) {
       const [coValueID, entry] = coValuesToCopy[coValuesToCopy.length - 1]!;
 
-      if (entry.state.type !== "available") {
+      if (!entry.isAvailable()) {
         coValuesToCopy.pop();
         continue;
       } else {
-        const allDepsCopied = entry.state.coValue
+        const allDepsCopied = entry.core
           .getDependedOnCoValues()
-          .every(
-            (dep) => newNode.coValuesStore.get(dep).state.type === "available",
-          );
+          .every((dep) => newNode.coValuesStore.get(dep).isAvailable());
 
         if (!allDepsCopied) {
           // move to end of queue
@@ -655,12 +661,15 @@ export class LocalNode {
         }
 
         const newCoValue = new CoValueCore(
-          entry.state.coValue.header,
+          entry.core.header,
           newNode,
-          new Map(entry.state.coValue.sessionLogs),
+          new Map(entry.core.sessionLogs),
         );
 
-        newNode.coValuesStore.setAsAvailable(coValueID, newCoValue);
+        newNode.coValuesStore.internalMarkMagicallyAvailable(
+          coValueID,
+          newCoValue,
+        );
 
         coValuesToCopy.pop();
       }

package/src/sync.ts

@@ -163,7 +163,7 @@ export class SyncManager {
   }
 
   async handleSyncMessage(msg: SyncMessage, peer: PeerState) {
-    if (peer.erroredCoValues.has(msg.id)) {
+    if (this.local.coValuesStore.get(msg.id).isErroredInPeer(peer.id)) {
       logger.warn(
         `Skipping message ${msg.action} on errored coValue ${msg.id} from peer ${peer.id}`,
       );
@@ -251,8 +251,8 @@ export class SyncManager {
       for (const id of coValue.getDependedOnCoValues()) {
         const entry = this.local.coValuesStore.get(id);
 
-        if (entry.state.type === "available") {
-          buildOrderedCoValueList(entry.state.coValue);
+        if (entry.isAvailable()) {
+          buildOrderedCoValueList(entry.core);
         }
       }
 
@@ -260,23 +260,20 @@ export class SyncManager {
     };
 
     for (const entry of this.local.coValuesStore.getValues()) {
-      switch (entry.state.type) {
-        case "unavailable":
-          // If the coValue is unavailable and we never tried this peer
-          // we try to load it from the peer
-          if (!peer.toldKnownState.has(entry.id)) {
-            await entry.loadFromPeers([peer]).catch((e: unknown) => {
-              logger.error("Error sending load", { err: e });
-            });
-          }
-          break;
-        case "available":
-          const coValue = entry.state.coValue;
-
-          // Build the list of coValues ordered by dependency
-          // so we can send the load message in the correct order
-          buildOrderedCoValueList(coValue);
-          break;
+      if (!entry.isAvailable()) {
+        // If the coValue is unavailable and we never tried this peer
+        // we try to load it from the peer
+        if (!peer.toldKnownState.has(entry.id)) {
+          await entry.loadFromPeers([peer]).catch((e: unknown) => {
+            logger.error("Error sending load", { err: e });
+          });
+        }
+      } else {
+        const coValue = entry.core;
+
+        // Build the list of coValues ordered by dependency
+        // so we can send the load message in the correct order
+        buildOrderedCoValueList(coValue);
       }
 
       // Fill the missing known states with empty known states
@@ -399,7 +396,10 @@ export class SyncManager {
     peer.setKnownState(msg.id, knownStateIn(msg));
     const entry = this.local.coValuesStore.get(msg.id);
 
-    if (entry.state.type === "unknown" || entry.state.type === "unavailable") {
+    if (
+      entry.highLevelState === "unknown" ||
+      entry.highLevelState === "unavailable"
+    ) {
       const eligiblePeers = this.getServerAndStoragePeers(peer.id);
 
       if (eligiblePeers.length === 0) {
@@ -426,7 +426,7 @@ export class SyncManager {
       }
     }
 
-    if (entry.state.type === "loading") {
+    if (entry.highLevelState === "loading") {
       // We need to return from handleLoad immediately and wait for the CoValue to be loaded
       // in a new task, otherwise we might block further incoming content messages that would
       // resolve the CoValue as available. This can happen when we receive fresh
@@ -456,7 +456,7 @@ export class SyncManager {
             err: e,
           });
         });
-    } else if (entry.state.type === "available") {
+    } else if (entry.isAvailable()) {
       await this.sendNewContentIncludingDependencies(msg.id, peer);
     } else {
       this.trySendToPeer(peer, {
@@ -475,20 +475,13 @@ export class SyncManager {
 
     // The header is a boolean value that tells us if the other peer do have information about the header.
     // If it's false in this point it means that the coValue is unavailable on the other peer.
-    if (entry.state.type !== "available") {
-      const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
+    const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
 
-      if (!availableOnPeer) {
-        entry.dispatch({
-          type: "not-found-in-peer",
-          peerId: peer.id,
-        });
-      }
-
-      return;
+    if (!availableOnPeer) {
+      entry.markNotFoundInPeer(peer.id);
     }
 
-    if (entry.state.type === "available") {
+    if (entry.isAvailable()) {
       await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
   }
@@ -511,7 +504,7 @@ export class SyncManager {
 
     let coValue: CoValueCore;
 
-    if (entry.state.type !== "available") {
+    if (!entry.isAvailable()) {
       if (!msg.header) {
         this.trySendToPeer(peer, {
           action: "known",
@@ -533,12 +526,9 @@ export class SyncManager {
 
       coValue = new CoValueCore(msg.header, this.local);
 
-      entry.dispatch({
-        type: "available",
-        coValue,
-      });
+      entry.markAvailable(coValue, peer.id);
     } else {
-      coValue = entry.state.coValue;
+      coValue = entry.core;
     }
 
     let invalidStateAssumed = false;
@@ -581,7 +571,7 @@ export class SyncManager {
           id: msg.id,
           err: result.error,
         });
-        peer.erroredCoValues.set(msg.id, result.error);
+        entry.markErrored(peer.id, result.error);
         continue;
       }
 
@@ -671,7 +661,8 @@ export class SyncManager {
   async actuallySyncCoValue(coValue: CoValueCore) {
     for (const peer of this.peersInPriorityOrder()) {
       if (peer.closed) continue;
-      if (peer.erroredCoValues.has(coValue.id)) continue;
+      if (this.local.coValuesStore.get(coValue.id).isErroredInPeer(peer.id))
+        continue;
 
       if (peer.optimisticKnownStates.has(coValue.id)) {
         await this.sendNewContentIncludingDependencies(coValue.id, peer);
@@ -726,7 +717,8 @@ export class SyncManager {
     const coValues = this.local.coValuesStore.getValues();
     const validCoValues = Array.from(coValues).filter(
       (coValue) =>
-        coValue.state.type === "available" || coValue.state.type === "loading",
+        coValue.highLevelState === "available" ||
+        coValue.highLevelState === "loading",
     );
 
     return Promise.all(