Implement request caching with deduplication and abort handling

Author: Oksamies

apps/cyberstorm-remix/cyberstorm/utils/__tests__/requestCache.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi } from "vitest";
+import { getCachedRequestPromise } from "../requestCache";
+
+describe("requestCache", () => {
+  it("caches result per request", async () => {
+    const mockFn = vi.fn().mockResolvedValue("result");
+    const request = new Request("http://localhost");
+
+    const result1 = await getCachedRequestPromise(
+      "mockFn",
+      mockFn,
+      ["arg1"],
+      request
+    );
+    const result2 = await getCachedRequestPromise(
+      "mockFn",
+      mockFn,
+      ["arg1"],
+      request
+    );
+
+    expect(result1).toBe("result");
+    expect(result2).toBe("result");
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not share cache between requests", async () => {
+    const mockFn = vi.fn().mockResolvedValue("result");
+    const request1 = new Request("http://localhost");
+    const request2 = new Request("http://localhost");
+
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request1);
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request2);
+
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it("throws error for restricted function names", () => {
+    const mockFn = async () => "result";
+    const request = new Request("http://localhost");
+
+    expect(() =>
+      getCachedRequestPromise("default", mockFn, [], request)
+    ).toThrow("Must be named functions to support caching.");
+  });
+
+  it("allows caching if a valid name is provided", async () => {
+    const mockFn = async () => "result";
+    const request = new Request("http://localhost");
+
+    const result = await getCachedRequestPromise(
+      "customLabel",
+      mockFn,
+      [],
+      request
+    );
+    expect(result).toBe("result");
+  });
+
+  it("clears request cache on abort", async () => {
+    const mockFn = vi.fn().mockResolvedValue("result");
+    const controller = new AbortController();
+    const request = new Request("http://localhost", {
+      signal: controller.signal,
+    });
+
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request);
+
+    // Abort the request
+    controller.abort();
+
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request);
+
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it("should behave consistently if request is aborted BEFORE first use", async () => {
+    const mockFn = vi.fn().mockResolvedValue("result");
+    const controller = new AbortController();
+    const request = new Request("http://localhost", {
+      signal: controller.signal,
+    });
+
+    // Abort before first use
+    controller.abort();
+
+    // First use: populates cache (unavoidable currently as we push after check)
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // Second use: should be cleared/ignored and re-executed?
+    // Currently it returns cached value because listener wasn't attached.
+    await getCachedRequestPromise("mockFn", mockFn, ["arg1"], request);
+
+    // If consistent with above, it should be 2.
+    // If inconsistent (bug), it is 1.
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+});

apps/cyberstorm-remix/cyberstorm/utils/requestCache.ts

@@ -0,0 +1,69 @@
+import isEqual from "lodash/isEqual";
+
+const restrictedNames = new Set(["", "anonymous", "default"]);
+
+type CacheEntry = {
+  funcName: string;
+  inputs: unknown[];
+  promise: Promise<unknown>;
+};
+
+const requestScopedCaches = new WeakMap<Request, CacheEntry[]>();
+function getCache(request: Request) {
+  let cache = requestScopedCaches.get(request);
+  if (!cache) {
+    cache = [];
+    requestScopedCaches.set(request, cache);
+
+    const signal = request.signal;
+    if (signal) {
+      if (signal.aborted) {
+        cache.splice(0, cache.length);
+      } else {
+        signal.addEventListener(
+          "abort",
+          () => {
+            cache?.splice(0, cache.length);
+          },
+          { once: true }
+        );
+      }
+    }
+  }
+
+  if (request.signal?.aborted) {
+    cache.splice(0, cache.length);
+  }
+
+  return cache;
+}
+
+export function getCachedRequestPromise<Args extends unknown[], Result>(
+  funcName: string,
+  func: (...inputs: Args) => Promise<Result>,
+  inputs: Args,
+  request: Request
+): Promise<Result> {
+  if (restrictedNames.has(funcName)) {
+    throw new Error("Must be named functions to support caching.");
+  }
+
+  const cache = getCache(request);
+  for (const cacheEntry of cache) {
+    if (
+      cacheEntry.funcName === funcName &&
+      isEqual(cacheEntry.inputs, inputs)
+    ) {
+      return cacheEntry.promise as Promise<Result>;
+    }
+  }
+
+  const promise = func(...inputs) as Promise<Result>;
+  cache.push({
+    funcName: funcName,
+    inputs,
+    promise,
+  });
+
+  return promise;
+}