@vantran-se/openchamber-web 1.23.0 → 1.24.3

package/server/lib/git/serial-refresh.js

@@ -0,0 +1,93 @@
+// Runs one refresh per key at a time and bounds how many keys refresh at once.
+//
+// A request that arrives while a refresh for its key is running does not join
+// that run: the run may have read the working tree before the change the
+// caller just made. Instead the request waits for one follow-up run that starts
+// after the current one finishes, so every caller receives a result at least as
+// fresh as its own arrival. All requests that arrive during one run share the
+// same follow-up, which caps the work per key at "one running, one pending"
+// no matter how many callers ask.
+
+export function createSerialRefresh({ maxConcurrent = Number.POSITIVE_INFINITY } = {}) {
+  const runs = new Map();
+  let running = 0;
+  const waiting = [];
+
+  const acquire = () => new Promise((resolve) => {
+    if (running < maxConcurrent) {
+      running += 1;
+      resolve();
+      return;
+    }
+    waiting.push(resolve);
+  });
+
+  const release = () => {
+    const next = waiting.shift();
+    if (next) {
+      next();
+      return;
+    }
+    running -= 1;
+  };
+
+  const start = (key, requests, execute, deferred) => {
+    const run = { follower: null };
+    runs.set(key, run);
+    const promise = (async () => {
+      await acquire();
+      try {
+        return await execute(requests);
+      } finally {
+        release();
+      }
+    })();
+    if (deferred) {
+      promise.then(deferred.resolve, deferred.reject);
+    }
+    promise
+      .catch(() => undefined)
+      .then(() => {
+        if (runs.get(key) !== run) return;
+        if (run.follower) {
+          const follower = run.follower;
+          start(key, follower.requests, follower.execute, follower);
+          return;
+        }
+        runs.delete(key);
+      });
+    return promise;
+  };
+
+  return {
+    /**
+     * @template TRequest, TResult
+     * @param {string} key
+     * @param {TRequest} request
+     * @param {(requests: TRequest[]) => Promise<TResult>} execute receives every
+     *   request the run answers, so it can widen the work to satisfy all of them
+     * @returns {Promise<TResult>}
+     */
+    run(key, request, execute) {
+      const current = runs.get(key);
+      if (!current) {
+        return start(key, [request], execute);
+      }
+      if (!current.follower) {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+          resolve = res;
+          reject = rej;
+        });
+        current.follower = { requests: [], execute, promise, resolve, reject };
+      }
+      current.follower.requests.push(request);
+      return current.follower.promise;
+    },
+    /** Keys with a running or pending refresh. Exposed for tests. */
+    get activeKeys() {
+      return Array.from(runs.keys());
+    },
+  };
+}

package/server/lib/git/serial-refresh.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { createSerialRefresh } from './serial-refresh.js';
+
+const createGate = () => {
+  let release;
+  const opened = new Promise((resolve) => {
+    release = resolve;
+  });
+  return { opened, release };
+};
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe('createSerialRefresh', () => {
+  it('runs one refresh per key and answers later callers with one follow-up run', async () => {
+    const refresh = createSerialRefresh();
+    const gates = [createGate(), createGate()];
+    const executions = [];
+    const execute = async (requests) => {
+      const index = executions.length;
+      executions.push(requests);
+      await gates[index].opened;
+      return `run-${index}`;
+    };
+
+    const first = refresh.run('repo', 'a', execute);
+    await flush();
+    const second = refresh.run('repo', 'b', execute);
+    const third = refresh.run('repo', 'c', execute);
+    await flush();
+
+    expect(executions).toEqual([['a']]);
+
+    gates[0].release();
+    await expect(first).resolves.toBe('run-0');
+    await flush();
+    expect(executions).toEqual([['a'], ['b', 'c']]);
+
+    gates[1].release();
+    await expect(second).resolves.toBe('run-1');
+    await expect(third).resolves.toBe('run-1');
+    await flush();
+    expect(refresh.activeKeys).toEqual([]);
+  });
+
+  it('never serves a caller from a run that started before it asked', async () => {
+    const refresh = createSerialRefresh();
+    const gate = createGate();
+    let reads = 0;
+    const execute = async () => {
+      reads += 1;
+      const value = reads;
+      if (value === 1) await gate.opened;
+      return value;
+    };
+
+    const early = refresh.run('repo', null, execute);
+    await flush();
+    const late = refresh.run('repo', null, execute);
+    gate.release();
+
+    await expect(early).resolves.toBe(1);
+    await expect(late).resolves.toBe(2);
+  });
+
+  it('keeps keys independent and bounds how many run at once', async () => {
+    const refresh = createSerialRefresh({ maxConcurrent: 2 });
+    const gates = new Map();
+    const started = [];
+    const execute = (key) => async () => {
+      started.push(key);
+      const gate = createGate();
+      gates.set(key, gate);
+      await gate.opened;
+      return key;
+    };
+
+    const runs = ['a', 'b', 'c'].map((key) => refresh.run(key, null, execute(key)));
+    await flush();
+    expect(started).toEqual(['a', 'b']);
+
+    gates.get('a').release();
+    await flush();
+    expect(started).toEqual(['a', 'b', 'c']);
+
+    gates.get('b').release();
+    gates.get('c').release();
+    await expect(Promise.all(runs)).resolves.toEqual(['a', 'b', 'c']);
+  });
+
+  it('propagates a failed run to its callers and still runs the follow-up', async () => {
+    const refresh = createSerialRefresh();
+    const gate = createGate();
+    let calls = 0;
+    const execute = async () => {
+      calls += 1;
+      if (calls === 1) {
+        await gate.opened;
+        throw new Error('first failed');
+      }
+      return 'ok';
+    };
+
+    const first = refresh.run('repo', null, execute);
+    await flush();
+    const second = refresh.run('repo', null, execute);
+    gate.release();
+
+    await expect(first).rejects.toThrow('first failed');
+    await expect(second).resolves.toBe('ok');
+  });
+});