cojson 0.8.12 → 0.8.17

package/src/PeerKnownStates.ts

@@ -1,108 +1,116 @@
 import { RawCoID, SessionID } from "./ids.js";
-import { CoValueKnownState, emptyKnownState, combinedKnownStates } from "./sync.js";
-
-type PeerKnownStateActions = {
-    type: "SET_AS_EMPTY";
-    id: RawCoID;
-} | {
-    type: "UPDATE_HEADER";
-    id: RawCoID;
-    header: boolean;
-} |
-{
-    type: "UPDATE_SESSION_COUNTER";
-    id: RawCoID;
-    sessionId: SessionID;
-    value: number;
-} |
-{
-    type: "SET";
-    id: RawCoID;
-    value: CoValueKnownState;
-} |
-{
-    type: "COMBINE_WITH";
-    id: RawCoID;
-    value: CoValueKnownState;
-};
+import {
+  CoValueKnownState,
+  combinedKnownStates,
+  emptyKnownState,
+} from "./sync.js";
+
+type PeerKnownStateActions =
+  | {
+      type: "SET_AS_EMPTY";
+      id: RawCoID;
+    }
+  | {
+      type: "UPDATE_HEADER";
+      id: RawCoID;
+      header: boolean;
+    }
+  | {
+      type: "UPDATE_SESSION_COUNTER";
+      id: RawCoID;
+      sessionId: SessionID;
+      value: number;
+    }
+  | {
+      type: "SET";
+      id: RawCoID;
+      value: CoValueKnownState;
+    }
+  | {
+      type: "COMBINE_WITH";
+      id: RawCoID;
+      value: CoValueKnownState;
+    };
 
 export class PeerKnownStates {
-    private coValues = new Map<RawCoID, CoValueKnownState>();
+  private coValues = new Map<RawCoID, CoValueKnownState>();
 
-    private updateHeader(id: RawCoID, header: boolean) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        knownState.header = header;
-        this.coValues.set(id, knownState);
-    }
+  private updateHeader(id: RawCoID, header: boolean) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    knownState.header = header;
+    this.coValues.set(id, knownState);
+  }
 
-    private combineWith(id: RawCoID, value: CoValueKnownState) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        this.coValues.set(id, combinedKnownStates(knownState, value));
-    }
+  private combineWith(id: RawCoID, value: CoValueKnownState) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    this.coValues.set(id, combinedKnownStates(knownState, value));
+  }
 
-    private updateSessionCounter(
-        id: RawCoID,
-        sessionId: SessionID,
-        value: number
-    ) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        const currentValue = knownState.sessions[sessionId] || 0;
-        knownState.sessions[sessionId] = Math.max(currentValue, value);
+  private updateSessionCounter(
+    id: RawCoID,
+    sessionId: SessionID,
+    value: number,
+  ) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    const currentValue = knownState.sessions[sessionId] || 0;
+    knownState.sessions[sessionId] = Math.max(currentValue, value);
 
-        this.coValues.set(id, knownState);
-    }
+    this.coValues.set(id, knownState);
+  }
 
-    get(id: RawCoID) {
-        return this.coValues.get(id);
-    }
+  get(id: RawCoID) {
+    return this.coValues.get(id);
+  }
 
-    has(id: RawCoID) {
-        return this.coValues.has(id);
-    }
+  has(id: RawCoID) {
+    return this.coValues.has(id);
+  }
+
+  clone() {
+    const clone = new PeerKnownStates();
+    clone.coValues = new Map(this.coValues);
+    return clone;
+  }
 
-    dispatch(action: PeerKnownStateActions) {
-        switch (action.type) {
-            case "UPDATE_HEADER":
-                this.updateHeader(action.id, action.header);
-                break;
-            case "UPDATE_SESSION_COUNTER":
-                this.updateSessionCounter(
-                    action.id,
-                    action.sessionId,
-                    action.value
-                );
-                break;
-            case "SET":
-                this.coValues.set(action.id, action.value);
-                break;
-            case "COMBINE_WITH":
-                this.combineWith(action.id, action.value);
-                break;
-            case "SET_AS_EMPTY":
-                this.coValues.set(action.id, emptyKnownState(action.id));
-                break;
-        }
-
-        this.triggerUpdate(action.id);
+  dispatch(action: PeerKnownStateActions) {
+    switch (action.type) {
+      case "UPDATE_HEADER":
+        this.updateHeader(action.id, action.header);
+        break;
+      case "UPDATE_SESSION_COUNTER":
+        this.updateSessionCounter(action.id, action.sessionId, action.value);
+        break;
+      case "SET":
+        this.coValues.set(action.id, action.value);
+        break;
+      case "COMBINE_WITH":
+        this.combineWith(action.id, action.value);
+        break;
+      case "SET_AS_EMPTY":
+        this.coValues.set(action.id, emptyKnownState(action.id));
+        break;
     }
 
-    listeners = new Set<(id: RawCoID, knownState: CoValueKnownState) => void>();
+    this.triggerUpdate(action.id);
+  }
 
-    triggerUpdate(id: RawCoID) {
-        this.trigger(id, this.coValues.get(id) ?? emptyKnownState(id));
-    }
+  listeners = new Set<(id: RawCoID, knownState: CoValueKnownState) => void>();
+
+  triggerUpdate(id: RawCoID) {
+    this.trigger(id, this.coValues.get(id) ?? emptyKnownState(id));
+  }
 
-    private trigger(id: RawCoID, knownState: CoValueKnownState) {
-        for (const listener of this.listeners) {
-            listener(id, knownState);
-        }
+  private trigger(id: RawCoID, knownState: CoValueKnownState) {
+    for (const listener of this.listeners) {
+      listener(id, knownState);
     }
+  }
 
-    subscribe(listener: (id: RawCoID, knownState: CoValueKnownState) => void) {
-        this.listeners.add(listener);
+  subscribe(listener: (id: RawCoID, knownState: CoValueKnownState) => void) {
+    this.listeners.add(listener);
 
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
 }

package/src/PeerState.ts

@@ -1,91 +1,110 @@
-import { RawCoID } from "./ids.js";
 import { PeerKnownStates } from "./PeerKnownStates.js";
-import { CO_VALUE_PRIORITY } from "./priority.js";
 import {
-    PriorityBasedMessageQueue,
-    QueueEntry,
+  PriorityBasedMessageQueue,
+  QueueEntry,
 } from "./PriorityBasedMessageQueue.js";
+import { RawCoID } from "./ids.js";
+import { CO_VALUE_PRIORITY } from "./priority.js";
 import { Peer, SyncMessage } from "./sync.js";
 
 export class PeerState {
-    constructor(private peer: Peer) {}
-
-    readonly optimisticKnownStates = new PeerKnownStates();
-    readonly toldKnownState: Set<RawCoID> = new Set();
-
-    get id() {
-        return this.peer.id;
+  constructor(
+    private peer: Peer,
+    knownStates: PeerKnownStates | undefined,
+  ) {
+    this.optimisticKnownStates = knownStates?.clone() ?? new PeerKnownStates();
+    this.knownStates = 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;
+
+  /**
+   * This one collects the known states "optimistically".
+   * We use it to keep track of the content we have sent to a given peer.
+   *
+   * 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.
+   */
+  readonly optimisticKnownStates: PeerKnownStates;
+  readonly toldKnownState: Set<RawCoID> = new Set();
+
+  get id() {
+    return this.peer.id;
+  }
+
+  get role() {
+    return this.peer.role;
+  }
+
+  get priority() {
+    return this.peer.priority;
+  }
+
+  get crashOnClose() {
+    return this.peer.crashOnClose;
+  }
+
+  isServerOrStoragePeer() {
+    return this.peer.role === "server" || this.peer.role === "storage";
+  }
+
+  /**
+   * We set as default priority HIGH to handle all the messages without a
+   * priority property as HIGH priority.
+   *
+   * This way we consider all the non-content messsages as HIGH priority.
+   */
+  private queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.HIGH);
+  private processing = false;
+  public closed = false;
+
+  async processQueue() {
+    if (this.processing) {
+      return;
     }
 
-    get role() {
-        return this.peer.role;
+    this.processing = true;
+
+    let entry: QueueEntry | undefined;
+    while ((entry = this.queue.pull())) {
+      // Awaiting the push to send one message at a time
+      // This way when the peer is "under pressure" we can enqueue all
+      // the coming messages and organize them by priority
+      await this.peer.outgoing
+        .push(entry.msg)
+        .then(entry.resolve)
+        .catch(entry.reject);
     }
 
-    get priority() {
-        return this.peer.priority;
-    }
+    this.processing = false;
+  }
 
-    get crashOnClose() {
-        return this.peer.crashOnClose;
-    }
+  pushOutgoingMessage(msg: SyncMessage) {
+    const promise = this.queue.push(msg);
 
-    isServerOrStoragePeer() {
-        return this.peer.role === "server" || this.peer.role === "storage";
-    }
-
-    /**
-     * We set as default priority HIGH to handle all the messages without a
-     * priority property as HIGH priority.
-     *
-     * This way we consider all the non-content messsages as HIGH priority.
-     */
-    private queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.HIGH);
-    private processing = false;
-    public closed = false;
-
-    async processQueue() {
-        if (this.processing) {
-            return;
-        }
-
-        this.processing = true;
-
-
-        let entry: QueueEntry | undefined;
-        while ((entry = this.queue.pull())) {
-            // Awaiting the push to send one message at a time
-            // This way when the peer is "under pressure" we can enqueue all
-            // the coming messages and organize them by priority
-            await this.peer.outgoing
-                .push(entry.msg)
-                .then(entry.resolve)
-                .catch(entry.reject);
-        }
-
-        this.processing = false;
-    }
-
-    pushOutgoingMessage(msg: SyncMessage) {
-        const promise = this.queue.push(msg);
+    void this.processQueue();
 
-        void this.processQueue();
+    return promise;
+  }
 
-        return promise;
+  get incoming() {
+    if (this.closed) {
+      return (async function* () {
+        yield "Disconnected" as const;
+      })();
     }
 
-    get incoming() {
-        if (this.closed) {
-            return (async function* () {
-                yield "Disconnected" as const;
-            })();
-        }
+    return this.peer.incoming;
+  }
 
-        return this.peer.incoming;
-    }
-
-    gracefulShutdown() {
-        console.debug("Gracefully closing", this.id);
-        this.peer.outgoing.close();
-        this.closed = true;
-    }
+  gracefulShutdown() {
+    console.debug("Gracefully closing", this.id);
+    this.peer.outgoing.close();
+    this.closed = true;
+  }
 }

package/src/PriorityBasedMessageQueue.ts

@@ -2,76 +2,69 @@ import { CoValuePriority } from "./priority.js";
 import { SyncMessage } from "./sync.js";
 
 function promiseWithResolvers<R>() {
-    let resolve = (_: R) => {};
-    let reject = (_: unknown) => {};
+  let resolve = (_: R) => {};
+  let reject = (_: unknown) => {};
 
-    const promise = new Promise<R>((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
+  const promise = new Promise<R>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
 
-    return {
-        promise,
-        resolve,
-        reject,
-    };
+  return {
+    promise,
+    resolve,
+    reject,
+  };
 }
 
 export type QueueEntry = {
-    msg: SyncMessage;
-    promise: Promise<void>;
-    resolve: () => void;
-    reject: (_: unknown) => void;
+  msg: SyncMessage;
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (_: unknown) => void;
 };
 
 /**
  * Since we have a fixed range of priority values (0-7) we can create a fixed array of queues.
  */
-type Tuple<T, N extends number, A extends unknown[] = []> = A extends { length: N } ? A : Tuple<T, N, [...A, T]>;
+type Tuple<T, N extends number, A extends unknown[] = []> = A extends {
+  length: N;
+}
+  ? A
+  : Tuple<T, N, [...A, T]>;
 type QueueTuple = Tuple<QueueEntry[], 8>;
 
 export class PriorityBasedMessageQueue {
-    private queues: QueueTuple = [
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-    ];
-
-    private getQueue(priority: CoValuePriority) {
-        return this.queues[priority];
-    }
+  private queues: QueueTuple = [[], [], [], [], [], [], [], []];
 
-    constructor(
-        private defaultPriority: CoValuePriority,
-    ) {}
+  private getQueue(priority: CoValuePriority) {
+    return this.queues[priority];
+  }
 
-    public push(msg: SyncMessage) {
-        const { promise, resolve, reject } = promiseWithResolvers<void>();
-        const entry: QueueEntry = { msg, promise, resolve, reject };
+  constructor(private defaultPriority: CoValuePriority) {}
 
-        if ("priority" in msg) {
-            const queue = this.getQueue(msg.priority);
+  public push(msg: SyncMessage) {
+    const { promise, resolve, reject } = promiseWithResolvers<void>();
+    const entry: QueueEntry = { msg, promise, resolve, reject };
 
-            queue?.push(entry);
-        } else {
-            this.getQueue(this.defaultPriority).push(entry);
-        }
+    if ("priority" in msg) {
+      const queue = this.getQueue(msg.priority);
 
-        return promise;
+      queue?.push(entry);
+    } else {
+      this.getQueue(this.defaultPriority).push(entry);
     }
 
-    public pull() {
-        const activeQueue = this.queues.find((queue) => queue.length > 0);
+    return promise;
+  }
 
-        if (!activeQueue) {
-            return undefined;
-        }
+  public pull() {
+    const activeQueue = this.queues.find((queue) => queue.length > 0);
 
-        return activeQueue.shift();
+    if (!activeQueue) {
+      return undefined;
     }
+
+    return activeQueue.shift();
+  }
 }

package/src/SyncStateSubscriptionManager.ts

@@ -0,0 +1,124 @@
+import { RawCoID } from "./ids.js";
+import {
+  CoValueKnownState,
+  PeerID,
+  SyncManager,
+  emptyKnownState,
+} from "./sync.js";
+
+export class SyncStateSubscriptionManager {
+  constructor(private syncManager: SyncManager) {}
+
+  private listeners = new Set<
+    (
+      peerId: PeerID,
+      knownState: CoValueKnownState,
+      uploadCompleted: boolean,
+    ) => void
+  >();
+
+  private listenersByPeers = new Map<
+    PeerID,
+    Set<(knownState: CoValueKnownState, uploadCompleted: boolean) => void>
+  >();
+
+  subscribeToUpdates(
+    listener: (
+      peerId: PeerID,
+      knownState: CoValueKnownState,
+      uploadCompleted: boolean,
+    ) => void,
+  ) {
+    this.listeners.add(listener);
+
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  subscribeToPeerUpdates(
+    peerId: PeerID,
+    listener: (knownState: CoValueKnownState, uploadCompleted: boolean) => void,
+  ) {
+    const listeners = this.listenersByPeers.get(peerId) ?? new Set();
+
+    if (listeners.size === 0) {
+      this.listenersByPeers.set(peerId, listeners);
+    }
+
+    listeners.add(listener);
+
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+
+  triggerUpdate(peerId: PeerID, id: RawCoID) {
+    const peer = this.syncManager.peers[peerId];
+
+    if (!peer) {
+      return;
+    }
+
+    const peerListeners = this.listenersByPeers.get(peer.id);
+
+    // 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 fullyUploadedIntoPeer = this.getIsCoValueFullyUploadedIntoPeer(
+      peerId,
+      id,
+    );
+
+    for (const listener of this.listeners) {
+      listener(peerId, knownState, fullyUploadedIntoPeer);
+    }
+
+    if (!peerListeners) return;
+
+    for (const listener of peerListeners) {
+      listener(knownState, fullyUploadedIntoPeer);
+    }
+  }
+
+  getIsCoValueFullyUploadedIntoPeer(peerId: PeerID, id: RawCoID) {
+    const peer = this.syncManager.peers[peerId];
+    const entry = this.syncManager.local.coValues[id];
+
+    if (!peer || !entry) {
+      return false;
+    }
+
+    if (entry.state.type !== "available") {
+      return false;
+    }
+
+    const coValue = entry.state.coValue;
+    const knownState = peer.knownStates.get(id);
+
+    if (!knownState) {
+      return false;
+    }
+
+    return getIsUploadCompleted(
+      coValue.knownState().sessions,
+      knownState.sessions,
+    );
+  }
+}
+
+function getIsUploadCompleted(
+  from: Record<string, number>,
+  to: Record<string, number>,
+) {
+  for (const sessionId of Object.keys(from)) {
+    if (from[sessionId] !== to[sessionId]) {
+      return false;
+    }
+  }
+
+  return true;
+}