cojson 0.18.29 → 0.18.30

package/src/PeerState.ts

@@ -1,40 +1,55 @@
-import { PeerKnownStates, ReadonlyPeerKnownStates } from "./PeerKnownStates.js";
+import { PeerKnownState } from "./coValueCore/PeerKnownState.js";
 import { RawCoID, SessionID } from "./ids.js";
 import { CoValueKnownState } from "./knownState.js";
 import { logger } from "./logger.js";
 import { Peer, SyncMessage } from "./sync.js";
 
 export class PeerState {
-  constructor(
-    private peer: Peer,
-    knownStates: ReadonlyPeerKnownStates | undefined,
-  ) {
-    this._knownStates = knownStates?.clone() ?? new PeerKnownStates();
-    this._optimisticKnownStates = knownStates?.clone() ?? new PeerKnownStates();
-  }
-
   /**
    * Here we to collect all the known states that a given peer has told us about.
    *
    * This can be used to safely track the sync state of a coValue in a given peer.
    */
-  readonly _knownStates: PeerKnownStates;
+  private readonly _knownStates: Map<RawCoID, PeerKnownState>;
+
+  constructor(
+    private peer: Peer,
+    knownStates: Map<RawCoID, PeerKnownState> | undefined,
+  ) {
+    this._knownStates = knownStates ?? new Map();
+  }
+
+  getKnownState(id: RawCoID) {
+    return this._knownStates.get(id)?.value();
+  }
+
+  getOptimisticKnownState(id: RawCoID) {
+    return this._knownStates.get(id)?.optimisticValue();
+  }
 
-  get knownStates(): ReadonlyPeerKnownStates {
-    return this._knownStates;
+  isCoValueSubscribedToPeer(id: RawCoID) {
+    return this._knownStates.has(id);
   }
 
   /**
-   * This one collects the known states "optimistically".
-   * We use it to keep track of the content we have sent to a given peer.
+   * Closes the current peer state and creates a new one from a given peer,
+   * keeping the same known states.
    *
-   * The main difference with knownState is that this is updated when the content is sent to the peer without
-   * waiting for any acknowledgement from the peer.
+   * This is used to create a new peer state when a peer reconnects.
    */
-  readonly _optimisticKnownStates: PeerKnownStates;
+  newPeerStateFrom(peer: Peer) {
+    if (!this.closed) {
+      this.gracefulShutdown();
+    }
+
+    const knownStates = new Map<RawCoID, PeerKnownState>();
+    // On reconnect, we reset all the optimistic known states
+    // because we can't know if those syncs were successful or not
+    for (const knownState of this._knownStates.values()) {
+      knownStates.set(knownState.id, knownState.cloneWithoutOptimistic());
+    }
 
-  get optimisticKnownStates(): ReadonlyPeerKnownStates {
-    return this._optimisticKnownStates;
+    return new PeerState(peer, knownStates);
   }
 
   readonly toldKnownState: Set<RawCoID> = new Set();
@@ -49,35 +64,72 @@ export class PeerState {
     this.toldKnownState.add(id);
   }
 
+  private getOrCreateKnownState(id: RawCoID) {
+    let knownState = this._knownStates.get(id);
+
+    if (!knownState) {
+      knownState = new PeerKnownState(id, this.peer.id);
+      this._knownStates.set(id, knownState);
+    }
+
+    return knownState;
+  }
+
   updateHeader(id: RawCoID, header: boolean) {
-    this._knownStates.updateHeader(id, header);
-    this._optimisticKnownStates.updateHeader(id, header);
+    const knownState = this.getOrCreateKnownState(id);
+    knownState.updateHeader(header);
+    this.triggerUpdate(id, knownState);
   }
 
   combineWith(id: RawCoID, value: CoValueKnownState) {
-    this._knownStates.combineWith(id, value);
-    this._optimisticKnownStates.combineWith(id, value);
+    const knownState = this.getOrCreateKnownState(id);
+    knownState.combineWith(value);
+    this.triggerUpdate(id, knownState);
   }
 
   combineOptimisticWith(id: RawCoID, value: CoValueKnownState) {
-    this._optimisticKnownStates.combineWith(id, value);
+    const knownState = this.getOrCreateKnownState(id);
+    knownState.combineOptimisticWith(value);
+    this.triggerUpdate(id, knownState);
   }
 
-  updateSessionCounter(id: RawCoID, sessionId: SessionID, value: number) {
-    this._knownStates.updateSessionCounter(id, sessionId, value);
-    this._optimisticKnownStates.updateSessionCounter(id, sessionId, value);
+  setKnownState(id: RawCoID, payload: CoValueKnownState | "empty") {
+    const knownState = this.getOrCreateKnownState(id);
+    knownState.set(payload);
+    this.triggerUpdate(id, knownState);
   }
 
-  setKnownState(id: RawCoID, knownState: CoValueKnownState | "empty") {
-    this._knownStates.set(id, knownState);
-    this._optimisticKnownStates.set(id, knownState);
+  /**
+   * Emit a change event for a given coValue.
+   *
+   * This is used to notify subscribers that the known state of a coValue has changed,
+   * but the known state of the peer has not.
+   */
+  emitCoValueChange(id: RawCoID) {
+    if (this.peer.role === "client" && !this.isCoValueSubscribedToPeer(id)) {
+      return;
+    }
+
+    const knownState = this.getOrCreateKnownState(id);
+    this.triggerUpdate(id, knownState);
+  }
+
+  listeners = new Set<(id: RawCoID, value: PeerKnownState) => void>();
+
+  private triggerUpdate(id: RawCoID, value: PeerKnownState) {
+    for (const listener of this.listeners) {
+      listener(id, value);
+    }
   }
 
-  setOptimisticKnownState(
-    id: RawCoID,
-    knownState: CoValueKnownState | "empty",
+  subscribeToKnownStatesUpdates(
+    listener: (id: RawCoID, value: PeerKnownState) => void,
   ) {
-    this._optimisticKnownStates.set(id, knownState);
+    this.listeners.add(listener);
+
+    return () => {
+      this.listeners.delete(listener);
+    };
   }
 
   get id() {

package/src/SyncStateManager.ts

@@ -1,9 +1,6 @@
 import { RawCoID } from "./ids.js";
-import {
-  CoValueKnownState,
-  emptyKnownState,
-  areLocalSessionsUploaded,
-} from "./knownState.js";
+import { CoValueKnownState, areLocalSessionsUploaded } from "./knownState.js";
+import { PeerState } from "./PeerState.js";
 import { PeerID, SyncManager } from "./sync.js";
 
 export type SyncState = {
@@ -55,40 +52,17 @@ export class SyncStateManager {
     };
   }
 
-  getCurrentSyncState(peerId: PeerID, id: RawCoID) {
-    // Build a lazy sync state object to process the isUploaded info
-    // only when requested
-    const syncState = {} as SyncState;
-
-    const getIsUploaded = () =>
-      this.getIsCoValueFullyUploadedIntoPeer(peerId, id);
-
-    Object.defineProperties(syncState, {
-      uploaded: {
-        enumerable: true,
-        get: getIsUploaded,
-      },
-    });
-
-    return syncState;
-  }
-
-  triggerUpdate(peerId: PeerID, id: RawCoID) {
-    const peer = this.syncManager.peers[peerId];
-
-    if (!peer) {
-      return;
-    }
-
-    const peerListeners = this.listenersByPeers.get(peer.id);
+  triggerUpdate(peerId: PeerID, id: RawCoID, knownState: CoValueKnownState) {
+    const peerListeners = this.listenersByPeers.get(peerId);
 
     // If we don't have any active listeners do nothing
     if (!peerListeners?.size && !this.listeners.size) {
       return;
     }
 
-    const knownState = peer.knownStates.get(id) ?? emptyKnownState(id);
-    const syncState = this.getCurrentSyncState(peerId, id);
+    const syncState = {
+      uploaded: this.getIsCoValueFullyUploadedIntoPeer(knownState, id),
+    };
 
     for (const listener of this.listeners) {
       listener(peerId, knownState, syncState);
@@ -101,40 +75,31 @@ export class SyncStateManager {
     }
   }
 
-  private getKnownStateSessions(peerId: PeerID, id: RawCoID) {
-    const peer = this.syncManager.peers[peerId];
-
-    if (!peer) {
-      return undefined;
-    }
+  isSynced(peer: PeerState, id: RawCoID) {
+    const peerKnownState = peer.getKnownState(id);
 
-    const peerSessions = peer.knownStates.get(id)?.sessions;
+    if (!peerKnownState) return false;
 
-    if (!peerSessions) {
-      return undefined;
-    }
-
-    const entry = this.syncManager.local.getCoValue(id);
-
-    if (!entry.isAvailable()) {
-      return undefined;
-    }
-
-    const coValueSessions = entry.knownState().sessions;
-
-    return {
-      peer: peerSessions,
-      coValue: coValueSessions,
-    };
+    return this.getIsCoValueFullyUploadedIntoPeer(peerKnownState, id);
   }
 
-  private getIsCoValueFullyUploadedIntoPeer(peerId: PeerID, id: RawCoID) {
-    const sessions = this.getKnownStateSessions(peerId, id);
+  private getIsCoValueFullyUploadedIntoPeer(
+    peerKnownState: CoValueKnownState,
+    id: RawCoID,
+  ) {
+    const entry = this.syncManager.local.getCoValue(id);
 
-    if (!sessions) {
+    if (!entry.hasVerifiedContent()) {
       return false;
     }
 
-    return areLocalSessionsUploaded(sessions.coValue, sessions.peer);
+    // Accessing verified knownState to skip the immutability
+    // applied on CoValueCore
+    const knownState = entry.verified.knownState();
+
+    return areLocalSessionsUploaded(
+      knownState.sessions,
+      peerKnownState.sessions,
+    );
   }
 }

package/src/coValueContentMessage.ts

@@ -61,8 +61,10 @@ export function exceedsRecommendedSize(
   );
 }
 
+const cachedTextEncoder = new TextEncoder();
+
 export function validateTxSizeLimitInBytes(changes: JsonValue[]): void {
-  const serializedSize = new TextEncoder().encode(
+  const serializedSize = cachedTextEncoder.encode(
     JSON.stringify(changes),
   ).length;
   if (serializedSize > TRANSACTION_CONFIG.MAX_TX_SIZE_BYTES) {

package/src/coValueCore/PeerKnownState.ts

@@ -0,0 +1,74 @@
+import type { RawCoID } from "../ids.js";
+import {
+  cloneKnownState,
+  combineKnownStates,
+  CoValueKnownState,
+  emptyKnownState,
+} from "../knownState.js";
+import { PeerID } from "../sync.js";
+
+export class PeerKnownState {
+  readonly id: RawCoID;
+  readonly peerId: PeerID;
+  private knownState: CoValueKnownState;
+  private optimisticKnownState?: CoValueKnownState;
+
+  constructor(id: RawCoID, peerId: PeerID) {
+    this.id = id;
+    this.peerId = peerId;
+    this.knownState = emptyKnownState(id);
+  }
+
+  cloneWithoutOptimistic() {
+    const clone = new PeerKnownState(this.id, this.peerId);
+    clone.set(this.knownState);
+    return clone;
+  }
+
+  updateHeader(header: boolean) {
+    this.knownState.header = header;
+
+    if (this.optimisticKnownState) {
+      this.optimisticKnownState.header = header;
+    }
+  }
+
+  combineWith(value: CoValueKnownState) {
+    combineKnownStates(this.knownState, value);
+
+    if (this.optimisticKnownState) {
+      combineKnownStates(this.optimisticKnownState, value);
+    }
+  }
+
+  combineOptimisticWith(value: CoValueKnownState) {
+    if (!this.optimisticKnownState) {
+      this.optimisticKnownState = cloneKnownState(this.knownState);
+    }
+
+    combineKnownStates(this.optimisticKnownState, value);
+  }
+
+  /**
+   * Aligns the CoValue known state with the defined payload
+   */
+  set(payload: CoValueKnownState | "empty") {
+    if (payload === "empty") {
+      this.knownState.header = false;
+      this.knownState.sessions = {};
+    } else {
+      this.knownState.header = payload.header;
+      this.knownState.sessions = { ...payload.sessions };
+    }
+
+    this.optimisticKnownState = undefined;
+  }
+
+  value() {
+    return this.knownState;
+  }
+
+  optimisticValue() {
+    return this.optimisticKnownState ?? this.knownState;
+  }
+}