fix(sds): avoid overflow in message history storage

Author: fryorcraken

packages/sds/src/message_channel/mem_local_history.spec.ts

@@ -0,0 +1,50 @@
+import { expect } from "chai";
+
+import { MemLocalHistory } from "./mem_local_history.js";
+import { ContentMessage } from "./message.js";
+
+describe("MemLocalHistory", () => {
+  it("Cap max size when messages are pushed one at a time", () => {
+    const maxSize = 2;
+
+    const hist = new MemLocalHistory(maxSize);
+
+    hist.push(
+      new ContentMessage("1", "c", "a", [], 1n, undefined, new Uint8Array([1]))
+    );
+    expect(hist.length).to.eq(1);
+    hist.push(
+      new ContentMessage("2", "c", "a", [], 2n, undefined, new Uint8Array([2]))
+    );
+    expect(hist.length).to.eq(2);
+
+    hist.push(
+      new ContentMessage("3", "c", "a", [], 3n, undefined, new Uint8Array([3]))
+    );
+    expect(hist.length).to.eq(2);
+
+    expect(hist.findIndex((m) => m.messageId === "1")).to.eq(-1);
+    expect(hist.findIndex((m) => m.messageId === "2")).to.not.eq(-1);
+    expect(hist.findIndex((m) => m.messageId === "3")).to.not.eq(-1);
+  });
+
+  it("Cap max size when a pushed array is exceeding the cap", () => {
+    const maxSize = 2;
+
+    const hist = new MemLocalHistory(maxSize);
+
+    hist.push(
+      new ContentMessage("1", "c", "a", [], 1n, undefined, new Uint8Array([1]))
+    );
+    expect(hist.length).to.eq(1);
+    hist.push(
+      new ContentMessage("2", "c", "a", [], 2n, undefined, new Uint8Array([2])),
+      new ContentMessage("3", "c", "a", [], 3n, undefined, new Uint8Array([3]))
+    );
+    expect(hist.length).to.eq(2);
+
+    expect(hist.findIndex((m) => m.messageId === "1")).to.eq(-1);
+    expect(hist.findIndex((m) => m.messageId === "2")).to.not.eq(-1);
+    expect(hist.findIndex((m) => m.messageId === "3")).to.not.eq(-1);
+  });
+});

packages/sds/src/message_channel/mem_local_history.ts

@@ -2,18 +2,31 @@ import _ from "lodash";
 
 import { ContentMessage, isContentMessage } from "./message.js";
 
+export const DEFAULT_MAX_LENGTH = 10_000;
+
 /**
- * In-Memory implementation of a local store of messages.
+ * In-Memory implementation of a local history of messages.
  *
  * Messages are store in SDS chronological order:
  * - messages[0] is the oldest message
  * - messages[n] is the newest message
  *
  * Only stores content message: `message.lamportTimestamp` and `message.content` are present.
+ *
+ * Oldest messages are dropped when `maxLength` is reached.
+ * If an array of items longer than `maxLength` is pushed, dropping will happen
+ * at next push.
  */
 export class MemLocalHistory {
   private items: ContentMessage[] = [];
 
+  /**
+   * Construct a new in-memory local history
+   *
+   * @param maxLength The maximum number of message to store.
+   */
+  public constructor(private maxLength: number = DEFAULT_MAX_LENGTH) {}
+
   public get length(): number {
     return this.items.length;
   }
@@ -33,6 +46,12 @@ export class MemLocalHistory {
     // Remove duplicates by messageId while maintaining order
     this.items = _.uniqBy(combinedItems, "messageId");
 
+    // Let's drop older messages if max length is reached
+    if (this.length > this.maxLength) {
+      const numItemsToRemove = this.length - this.maxLength;
+      this.items.splice(0, numItemsToRemove);
+    }
+
     return this.items.length;
   }