feat: request_bundler.ts

Author: mini-bomba

README.md

@@ -57,6 +57,11 @@ extendGlobally();
 
 - `wait` - returns a promise that resolves after some time (the classic new promise -> set timeout that everyone had to write at least once)
 
+### request_bundler
+
+Contains the `RequestBundler` class, built on top of `ExtendedMap`.
+Provides a simple way to limit concurrent requests of the same type, while redirecting duplicates to existing tasks.
+
 ### semaphore
 
 Contains a simple async `Semaphore` class.

lib/request_bundler.ts

@@ -0,0 +1,30 @@
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { ExtendedMap } from "./map.ts";
+
+/**
+ * An async "lock" that redirects duplicate requests to currently running ones
+ */
+export class RequestBundler<K, R> {
+  private state = new ExtendedMap<K, Promise<R>>();
+
+  /**
+   * Runs a task within the context of the request bundler.
+   *
+   * It is guaranteed that only one task associated with a given key will be running at once.
+   *
+   * If there is no task running for a given key, this function will call the handler function and
+   * will save the returned promise until it is resolved.
+   * If there is a task already running for a given key, this function will NOT call the handler function,
+   * and will instead return a promise for the already running task.
+   */
+  public run(key: K, handler: () => Promise<R>): Promise<R> {
+    return this.state.getOrInsertWith(key, () => {
+      const promise = handler();
+      void promise.finally(() => {
+        this.state.delete(key);
+      });
+      return promise;
+    });
+  }
+}

package.json

@@ -47,6 +47,11 @@
       "import": "./dist/promises.js",
       "require": "./dist/promises.cjs"
     },
+    "./request_bundler": {
+      "types": "./dist/request_bundler.d.ts",
+      "import": "./dist/request_bundler.js",
+      "require": "./dist/request_bundler.cjs"
+    },
     "./semaphore": {
       "types": "./dist/semaphore.d.ts",
       "import": "./dist/semaphore.js",

test/request_bundler.test.ts

@@ -0,0 +1,101 @@
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { wait } from "../lib/promises.ts";
+import { RequestBundler } from "../lib/request_bundler.ts";
+
+describe("request_bundler.ts", function () {
+  this.timeout(700);
+  this.slow(450);
+
+  it("should bundle concurrent requests with the same key", async () => {
+    const handler = chai.spy(async () => {
+      await wait(100);
+      return 1;
+    });
+
+    const bundler = new RequestBundler();
+
+    const p1 = bundler.run("key1", handler);
+    const p2 = bundler.run("key1", handler);
+
+    expect(handler).to.have.been.called.exactly(1);
+    await expect(p1).to.eventually.equal(1);
+    await expect(p2).to.eventually.equal(1);
+  });
+
+  it("should not bundle concurrent requests with different keys", async () => {
+    const handler = chai.spy(async () => {
+      await wait(100);
+      return 1;
+    });
+
+    const bundler = new RequestBundler();
+
+    const p1 = bundler.run("key1", handler);
+    const p2 = bundler.run("key2", handler);
+
+    expect(handler).to.have.been.called.exactly(2);
+    await expect(p1).to.eventually.equal(1);
+    await expect(p2).to.eventually.equal(1);
+  });
+
+  it("should use the first handler for concurrent requests", async () => {
+    const handler1 = chai.spy(async () => {
+      await wait(100);
+      return 1;
+    });
+    const handler2 = chai.spy(async () => {
+      await wait(100);
+      return 2;
+    });
+
+    const bundler = new RequestBundler();
+
+    const p1 = bundler.run("key1", handler1);
+    const p2 = bundler.run("key1", handler2);
+
+    expect(handler1).to.have.been.called.exactly(1);
+    expect(handler2).to.not.have.been.called();
+    await expect(p1).to.eventually.equal(1);
+    await expect(p2).to.eventually.equal(1);
+  });
+
+  it("should forget about the request after it finishes", async () => {
+    const handler = chai.spy(async () => {
+      await wait(100);
+      return 1;
+    });
+
+    const bundler = new RequestBundler();
+
+    const p1 = bundler.run("key1", handler);
+    await expect(p1).to.eventually.equal(1);
+
+    const p2 = bundler.run("key1", handler);
+    await expect(p2).to.eventually.equal(1);
+
+    expect(handler).to.have.been.called.exactly(2);
+  });
+
+  it("should forget about the request if handler throws", async () => {
+    const handler1 = chai.spy(async () => {
+      await wait(100);
+      throw new Error("elo żelo");
+    });
+    const handler2 = chai.spy(async () => {
+      await wait(100);
+      return 1;
+    });
+
+    const bundler = new RequestBundler();
+
+    const p1 = bundler.run("key1", handler1);
+    await expect(p1).to.be.rejectedWith("elo żelo");
+
+    const p2 = bundler.run("key1", handler2);
+    await expect(p2).to.eventually.equal(1);
+
+    expect(handler1).to.have.been.called.exactly(1);
+    expect(handler2).to.have.been.called.exactly(1);
+  });
+});