homeio

1import "server-only";
2
3export type MemoizedAsync<T> = (() => Promise<T>) & {
4  /**
5   * Forgets the cached value, after the thing it describes has been changed.
6   * A call already in flight started before the change: its result is not kept.
7   */
8  invalidate(): void;
9};
10
11/**
12 * Reuses the result of `load` for `ttlMs`, and lets concurrent callers share the
13 * call in flight. An expensive probe (one that spawns commands, say) then runs
14 * at most once per `ttlMs`, however many requests and streams ask for it.
15 *
16 * A call that throws is not cached: the next caller tries again.
17 */
18export function memoizeAsync<T>(load: () => Promise<T>, ttlMs: number): MemoizedAsync<T> {
19  let cached: { value: T; expiresAt: number } | null = null;
20  let inFlight: Promise<T> | null = null;
21  let generation = 0;
22
23  const memoized = () => {
24    if (cached && cached.expiresAt > Date.now()) {
25      return Promise.resolve(cached.value);
26    }
27    if (inFlight) return inFlight;
28
29    const startedIn = generation;
30    const call = load()
31      .then((value) => {
32        if (startedIn === generation) {
33          cached = { value, expiresAt: Date.now() + ttlMs };
34        }
35        return value;
36      })
37      .finally(() => {
38        if (inFlight === call) inFlight = null;
39      });
40    inFlight = call;
41    return call;
42  };
43
44  memoized.invalidate = () => {
45    generation += 1;
46    cached = null;
47    inFlight = null;
48  };
49
50  return memoized;
51}
52