cojson 0.13.11 → 0.13.13

package/src/coValueState.ts

@@ -1,249 +1,205 @@
 import { ValueType } from "@opentelemetry/api";
 import { UpDownCounter, metrics } from "@opentelemetry/api";
 import { PeerState } from "./PeerState.js";
-import { CoValueCore } from "./coValueCore.js";
+import { CoValueCore, TryAddTransactionsError } from "./coValueCore.js";
 import { RawCoID } from "./ids.js";
 import { logger } from "./logger.js";
-import { PeerID } from "./sync.js";
+import { PeerID, emptyKnownState } from "./sync.js";
 
 export const CO_VALUE_LOADING_CONFIG = {
   MAX_RETRIES: 2,
   TIMEOUT: 30_000,
 };
 
-export class CoValueUnknownState {
-  type = "unknown" as const;
-}
-
-export class CoValueLoadingState {
-  type = "loading" as const;
+export class CoValueState {
   private peers = new Map<
     PeerID,
-    ReturnType<typeof createResolvablePromise<void>>
+    | { type: "unknown" | "pending" | "available" | "unavailable" }
+    | {
+        type: "errored";
+        error: TryAddTransactionsError;
+      }
   >();
-  private resolveResult: (value: CoValueCore | "unavailable") => void;
-
-  result: Promise<CoValueCore | "unavailable">;
-
-  constructor(peersIds: Iterable<PeerID>) {
-    this.peers = new Map();
-
-    for (const peerId of peersIds) {
-      this.peers.set(peerId, createResolvablePromise<void>());
-    }
 
-    const { resolve, promise } = createResolvablePromise<
-      CoValueCore | "unavailable"
-    >();
+  core: CoValueCore | null = null;
+  id: RawCoID;
 
-    this.result = promise;
-    this.resolveResult = resolve;
-  }
-
-  markAsUnavailable(peerId: PeerID) {
-    const entry = this.peers.get(peerId);
+  private listeners: Set<(state: CoValueState) => void> = new Set();
+  private counter: UpDownCounter;
 
-    if (entry) {
-      entry.resolve();
-    }
+  constructor(id: RawCoID) {
+    this.id = id;
 
-    this.peers.delete(peerId);
+    this.counter = metrics
+      .getMeter("cojson")
+      .createUpDownCounter("jazz.covalues.loaded", {
+        description: "The number of covalues in the system",
+        unit: "covalue",
+        valueType: ValueType.INT,
+      });
 
-    // If none of the peers have the coValue, we resolve to unavailable
-    if (this.peers.size === 0) {
-      this.resolve("unavailable");
-    }
+    this.updateCounter(null);
   }
 
-  resolve(value: CoValueCore | "unavailable") {
-    this.resolveResult(value);
-    for (const entry of this.peers.values()) {
-      entry.resolve();
+  get highLevelState() {
+    if (this.core) {
+      return "available";
+    } else if (this.peers.size === 0) {
+      return "unknown";
     }
-    this.peers.clear();
-  }
-
-  // Wait for a specific peer to have a known state
-  waitForPeer(peerId: PeerID) {
-    const entry = this.peers.get(peerId);
 
-    if (!entry) {
-      return Promise.resolve();
+    for (const peer of this.peers.values()) {
+      if (peer.type === "pending") {
+        return "loading";
+      } else if (peer.type === "unknown") {
+        return "unknown";
+      }
     }
 
-    return entry.promise;
+    return "unavailable";
   }
-}
-
-export class CoValueAvailableState {
-  type = "available" as const;
-
-  constructor(public coValue: CoValueCore) {}
-}
-
-export class CoValueUnavailableState {
-  type = "unavailable" as const;
-}
 
-type CoValueStateAction =
-  | {
-      type: "load-requested";
-      peersIds: PeerID[];
-    }
-  | {
-      type: "not-found-in-peer";
-      peerId: PeerID;
-    }
-  | {
-      type: "available";
-      coValue: CoValueCore;
-    };
-
-type CoValueStateType =
-  | CoValueUnknownState
-  | CoValueLoadingState
-  | CoValueAvailableState
-  | CoValueUnavailableState;
-
-export class CoValueState {
-  promise?: Promise<CoValueCore | "unavailable">;
-  private resolve?: (value: CoValueCore | "unavailable") => void;
-  private counter: UpDownCounter;
-
-  constructor(
-    public id: RawCoID,
-    public state: CoValueStateType,
-  ) {
-    this.counter = metrics
-      .getMeter("cojson")
-      .createUpDownCounter("jazz.covalues.loaded", {
-        description: "The number of covalues in the system",
-        unit: "covalue",
-        valueType: ValueType.INT,
-      });
-
-    this.counter.add(1, {
-      state: this.state.type,
-    });
+  isErroredInPeer(peerId: PeerID) {
+    return this.peers.get(peerId)?.type === "errored";
   }
 
-  static Unknown(id: RawCoID) {
-    return new CoValueState(id, new CoValueUnknownState());
+  isAvailable(): this is { type: "available"; core: CoValueCore } {
+    return !!this.core;
   }
 
-  static Loading(id: RawCoID, peersIds: Iterable<PeerID>) {
-    return new CoValueState(id, new CoValueLoadingState(peersIds));
+  addListener(listener: (state: CoValueState) => void) {
+    this.listeners.add(listener);
+    listener(this);
   }
 
-  static Available(coValue: CoValueCore) {
-    return new CoValueState(coValue.id, new CoValueAvailableState(coValue));
+  removeListener(listener: (state: CoValueState) => void) {
+    this.listeners.delete(listener);
   }
 
-  static Unavailable(id: RawCoID) {
-    return new CoValueState(id, new CoValueUnavailableState());
+  private notifyListeners() {
+    for (const listener of this.listeners) {
+      listener(this);
+    }
   }
 
   async getCoValue() {
-    if (this.state.type === "available") {
-      return this.state.coValue;
-    }
-    if (this.state.type === "unavailable") {
+    if (this.highLevelState === "unavailable") {
       return "unavailable";
     }
 
-    // If we don't have a resolved state we return a new promise
-    // that will be resolved when the state will move to available or unavailable
-    if (!this.promise) {
-      const { promise, resolve } = createResolvablePromise<
-        CoValueCore | "unavailable"
-      >();
-
-      this.promise = promise;
-      this.resolve = resolve;
-    }
-
-    return this.promise;
-  }
-
-  private moveToState(value: CoValueStateType) {
-    this.counter.add(-1, {
-      state: this.state.type,
-    });
-    this.state = value;
+    return new Promise<CoValueCore>((resolve) => {
+      const listener = (state: CoValueState) => {
+        if (state.core) {
+          resolve(state.core);
+          this.removeListener(listener);
+        }
+      };
 
-    this.counter.add(1, {
-      state: this.state.type,
+      this.addListener(listener);
     });
+  }
 
-    if (!this.resolve) {
+  async loadFromPeers(peers: PeerState[]) {
+    if (peers.length === 0) {
       return;
     }
 
-    // If the state is available we resolve the promise
-    // and clear it to handle the possible transition from unavailable to available
-    if (value.type === "available") {
-      this.resolve(value.coValue);
-      this.clearPromise();
-    } else if (value.type === "unavailable") {
-      this.resolve("unavailable");
-      this.clearPromise();
-    }
-  }
+    const loadAttempt = async (peersToLoadFrom: PeerState[]) => {
+      const peersToActuallyLoadFrom = [];
+      for (const peer of peersToLoadFrom) {
+        const currentState = this.peers.get(peer.id);
 
-  private clearPromise() {
-    this.promise = undefined;
-    this.resolve = undefined;
-  }
+        if (currentState?.type === "available") {
+          continue;
+        }
 
-  async loadFromPeers(peers: PeerState[]) {
-    const state = this.state;
+        if (currentState?.type === "errored") {
+          continue;
+        }
 
-    if (state.type === "loading" || state.type === "available") {
-      return;
-    }
+        if (
+          currentState?.type === "unavailable" ||
+          currentState?.type === "pending"
+        ) {
+          if (peer.shouldRetryUnavailableCoValues()) {
+            this.markPending(peer.id);
+            peersToActuallyLoadFrom.push(peer);
+          }
 
-    if (peers.length === 0) {
-      this.moveToState(new CoValueUnavailableState());
-      return;
-    }
+          continue;
+        }
 
-    const doLoad = async (peersToLoadFrom: PeerState[]) => {
-      const peersWithoutErrors = getPeersWithoutErrors(
-        peersToLoadFrom,
-        this.id,
-      );
-
-      // If we are in the loading state we move to a new loading state
-      // to reset all the loading promises
-      if (
-        this.state.type === "loading" ||
-        this.state.type === "unknown" ||
-        this.state.type === "unavailable"
-      ) {
-        this.moveToState(
-          new CoValueLoadingState(peersWithoutErrors.map((p) => p.id)),
-        );
+        if (!currentState || currentState?.type === "unknown") {
+          this.markPending(peer.id);
+          peersToActuallyLoadFrom.push(peer);
+        }
       }
 
-      // Assign the current state to a variable to not depend on the state changes
-      // that may happen while we wait for loadCoValueFromPeers to complete
-      const currentState = this.state;
+      for (const peer of peersToActuallyLoadFrom) {
+        if (peer.closed) {
+          this.markNotFoundInPeer(peer.id);
+          continue;
+        }
 
-      // If we entered successfully the loading state, we load the coValue from the peers
-      //
-      // We may not enter the loading state if the coValue has become available in between
-      // of the retries
-      if (currentState.type === "loading") {
-        await loadCoValueFromPeers(this, peersWithoutErrors);
+        peer
+          .pushOutgoingMessage({
+            action: "load",
+            ...(this.core ? this.core.knownState() : emptyKnownState(this.id)),
+          })
+          .catch((err) => {
+            logger.warn(`Failed to push load message to peer ${peer.id}`, {
+              err,
+            });
+          });
 
-        const result = await currentState.result;
-        return result !== "unavailable";
-      }
+        /**
+         * Use a very long timeout for storage peers, because under pressure
+         * they may take a long time to consume the messages queue
+         *
+         * TODO: Track errors on storage and do not rely on timeout
+         */
+        const timeoutDuration =
+          peer.role === "storage"
+            ? CO_VALUE_LOADING_CONFIG.TIMEOUT * 10
+            : CO_VALUE_LOADING_CONFIG.TIMEOUT;
+
+        const waitingForPeer = new Promise<void>((resolve) => {
+          const markNotFound = () => {
+            if (this.peers.get(peer.id)?.type === "pending") {
+              this.markNotFoundInPeer(peer.id);
+            }
+          };
+
+          const timeout = setTimeout(markNotFound, timeoutDuration);
+          const removeCloseListener = peer.addCloseListener(markNotFound);
+
+          const listener = (state: CoValueState) => {
+            const peerState = state.peers.get(peer.id);
+            if (
+              state.isAvailable() || // might have become available from another peer e.g. through handleNewContent
+              peerState?.type === "available" ||
+              peerState?.type === "errored" ||
+              peerState?.type === "unavailable"
+            ) {
+              state.removeListener(listener);
+              removeCloseListener();
+              clearTimeout(timeout);
+              resolve();
+            }
+          };
+
+          this.addListener(listener);
+        });
 
-      return currentState.type === "available";
+        await waitingForPeer;
+      }
     };
 
-    await doLoad(peers);
+    await loadAttempt(peers);
+
+    if (this.isAvailable()) {
+      return;
+    }
 
     // Retry loading from peers that have the retry flag enabled
     const peersWithRetry = peers.filter((p) =>
@@ -251,129 +207,74 @@ export class CoValueState {
     );
 
     if (peersWithRetry.length > 0) {
+      const waitingForCoValue = new Promise<void>((resolve) => {
+        const listener = (state: CoValueState) => {
+          if (state.isAvailable()) {
+            resolve();
+            this.removeListener(listener);
+          }
+        };
+
+        this.addListener(listener);
+      });
+
       // We want to exit early if the coValue becomes available in between the retries
       await Promise.race([
-        this.getCoValue(),
+        waitingForCoValue,
         runWithRetry(
-          () => doLoad(peersWithRetry),
+          () => loadAttempt(peersWithRetry),
           CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
         ),
       ]);
     }
-
-    // If after the retries the coValue is still loading, we consider the load failed
-    if (this.state.type === "loading") {
-      this.moveToState(new CoValueUnavailableState());
-    }
   }
 
-  dispatch(action: CoValueStateAction) {
-    const currentState = this.state;
-
-    switch (action.type) {
-      case "available":
-        if (currentState.type === "loading") {
-          currentState.resolve(action.coValue);
-        }
-
-        // It should be always possible to move to the available state
-        this.moveToState(new CoValueAvailableState(action.coValue));
+  private updateCounter(previousState: string | null) {
+    const newState = this.highLevelState;
 
-        break;
-      case "not-found-in-peer":
-        if (currentState.type === "loading") {
-          currentState.markAsUnavailable(action.peerId);
-        }
-
-        break;
+    if (previousState !== newState) {
+      if (previousState) {
+        this.counter.add(-1, { state: previousState });
+      }
+      this.counter.add(1, { state: newState });
     }
   }
-}
 
-async function loadCoValueFromPeers(
-  coValueEntry: CoValueState,
-  peers: PeerState[],
-) {
-  for (const peer of peers) {
-    if (peer.closed) {
-      coValueEntry.dispatch({
-        type: "not-found-in-peer",
-        peerId: peer.id,
-      });
-      continue;
-    }
+  markNotFoundInPeer(peerId: PeerID) {
+    const previousState = this.highLevelState;
+    this.peers.set(peerId, { type: "unavailable" });
+    this.updateCounter(previousState);
+    this.notifyListeners();
+  }
 
-    if (coValueEntry.state.type === "available") {
-      /**
-       * We don't need to wait for the message to be delivered here.
-       *
-       * This way when the coValue becomes available because it's cached we don't wait for the server
-       * peer to consume the messages queue before moving forward.
-       */
-      peer
-        .pushOutgoingMessage({
-          action: "load",
-          ...coValueEntry.state.coValue.knownState(),
-        })
-        .catch((err) => {
-          logger.warn(`Failed to push load message to peer ${peer.id}`, {
-            err,
-          });
-        });
-    } else {
-      /**
-       * We only wait for the load state to be resolved.
-       */
-      peer
-        .pushOutgoingMessage({
-          action: "load",
-          id: coValueEntry.id,
-          header: false,
-          sessions: {},
-        })
-        .catch((err) => {
-          logger.warn(`Failed to push load message to peer ${peer.id}`, {
-            err,
-          });
-        });
-    }
+  // TODO: rename to "provided"
+  markAvailable(coValue: CoValueCore, fromPeerId: PeerID) {
+    const previousState = this.highLevelState;
+    this.core = coValue;
+    this.peers.set(fromPeerId, { type: "available" });
+    this.updateCounter(previousState);
+    this.notifyListeners();
+  }
 
-    if (coValueEntry.state.type === "loading") {
-      const { promise, resolve } = createResolvablePromise<void>();
-
-      /**
-       * Use a very long timeout for storage peers, because under pressure
-       * they may take a long time to consume the messages queue
-       *
-       * TODO: Track errors on storage and do not rely on timeout
-       */
-      const timeoutDuration =
-        peer.role === "storage"
-          ? CO_VALUE_LOADING_CONFIG.TIMEOUT * 10
-          : CO_VALUE_LOADING_CONFIG.TIMEOUT;
-
-      const handleTimeoutOrClose = () => {
-        if (coValueEntry.state.type === "loading") {
-          logger.warn("Failed to load coValue from peer", {
-            coValueId: coValueEntry.id,
-            peerId: peer.id,
-            peerRole: peer.role,
-          });
-          coValueEntry.dispatch({
-            type: "not-found-in-peer",
-            peerId: peer.id,
-          });
-          resolve();
-        }
-      };
+  internalMarkMagicallyAvailable(coValue: CoValueCore) {
+    const previousState = this.highLevelState;
+    this.core = coValue;
+    this.updateCounter(previousState);
+    this.notifyListeners();
+  }
 
-      const timeout = setTimeout(handleTimeoutOrClose, timeoutDuration);
-      const closeListener = peer.addCloseListener(handleTimeoutOrClose);
+  markErrored(peerId: PeerID, error: TryAddTransactionsError) {
+    const previousState = this.highLevelState;
+    this.peers.set(peerId, { type: "errored", error });
+    this.updateCounter(previousState);
+    this.notifyListeners();
+  }
 
-      await Promise.race([promise, coValueEntry.state.waitForPeer(peer.id)]);
-      clearTimeout(timeout);
-      closeListener();
-    }
+  private markPending(peerId: PeerID) {
+    const previousState = this.highLevelState;
+    this.peers.set(peerId, { type: "pending" });
+    this.updateCounter(previousState);
+    this.notifyListeners();
   }
 }
 
@@ -400,29 +301,6 @@ async function runWithRetry<T>(fn: () => Promise<T>, maxRetries: number) {
   }
 }
 
-function createResolvablePromise<T>() {
-  let resolve!: (value: T) => void;
-
-  const promise = new Promise<T>((res) => {
-    resolve = res;
-  });
-
-  return { promise, resolve };
-}
-
 function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-function getPeersWithoutErrors(peers: PeerState[], coValueId: RawCoID) {
-  return peers.filter((p) => {
-    if (p.erroredCoValues.has(coValueId)) {
-      logger.warn(
-        `Skipping load on errored coValue ${coValueId} from peer ${p.id}`,
-      );
-      return false;
-    }
-
-    return true;
-  });
-}

package/src/coValues/group.ts

@@ -186,8 +186,8 @@ export class RawGroup<
       const child = store.get(id);
 
       if (
-        child.state.type === "unknown" ||
-        child.state.type === "unavailable"
+        child.highLevelState === "unknown" ||
+        child.highLevelState === "unavailable"
       ) {
         child.loadFromPeers(peers).catch(() => {
           logger.error(`Failed to load child group ${id}`);

package/src/exports.ts

@@ -79,8 +79,6 @@ type Value = JsonValue | AnyRawCoValue;
 import { CO_VALUE_LOADING_CONFIG } from "./coValueState.js";
 import { logger } from "./logger.js";
 import { getPriorityFromHeader } from "./priority.js";
-import { FileSystem } from "./storage/FileSystem.js";
-import { BlockFilename, LSMStorage, WalFilename } from "./storage/index.js";
 
 /** @hidden */
 export const cojsonInternals = {
@@ -143,7 +141,6 @@ export {
   CryptoProvider,
   SyncMessage,
   isRawCoID,
-  LSMStorage,
   emptyKnownState,
   RawCoPlainText,
   stringifyOpID,
@@ -154,9 +151,6 @@ export {
 
 export type {
   Value,
-  FileSystem,
-  BlockFilename,
-  WalFilename,
   IncomingSyncStream,
   OutgoingSyncQueue,
   DisconnectedError,