Commit 229b05df042f896bbb44660c8524ffe222b85b8d | the-knife

author	Adamulek123 <adam.bogucki2018@gmail.com> 2026-08-24 11:55:34+02:00
committer	GitHub <noreply@github.com> 2026-08-24 02:55:34-07:00
log	229b05df042f896bbb44660c8524ffe222b85b8d
tree	6aacdcbebce1abcc4e71f5dbc3817c9412ebfbf0
parent	ba30177b5a5e9b47885b59afcc4f00a8a7cc0efd
signature	Signed by PGP key B5690EEEBB952194

fix(server): return fresh live pull request reads (#6472)

2 files changed, 51 insertions(+), 51 deletions(-)

apps
- server
  - src
    pullRequest
    PullRequestService.test.ts
    PullRequestService.ts

apps/server/src/pullRequest/PullRequestService.test.ts+37

...	@@ -1,6 +1,7 @@	...	@@ -1,6 +1,7 @@
1	import { assert, it } from "@effect/vitest";	1	import { assert, it } from "@effect/vitest";
2	import * as Effect from "effect/Effect";	2	import * as Effect from "effect/Effect";
3	import * as Layer from "effect/Layer";	3	import * as Layer from "effect/Layer";
		4	import * as TestClock from "effect/testing/TestClock";
4	import type {	5	import type {
5	OrchestrationProjectShell,	6	OrchestrationProjectShell,
6	ProjectId,	7	ProjectId,
...	@@ -2292,6 +2293,42 @@ it.effect("answers a repeated listing from cache, and concurrent readers share o	...	@@ -2292,6 +2293,42 @@ it.effect("answers a repeated listing from cache, and concurrent readers share o
2292	}),	2293	}),
2293	);	2294	);
2294		2295
		2296	it.effect("returns the refreshed listing on the first read after its cache expires", () =>
		2297	Effect.gen(function* () {
		2298	let hostCalls = 0;
		2299	const service = yield* makeService({
		2300	projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
		2301	providers: [
		2302	fakeProvider("github", {
		2303	listChangeRequests: () => {
		2304	hostCalls += 1;
		2305	return Effect.succeed({
		2306	items: [changeRequest(hostCalls, "2026-07-02T00:00:00Z")],
		2307	truncated: false,
		2308	continues: false,
		2309	});
		2310	},
		2311	}),
		2312	],
		2313	});
		2314
		2315	const first = yield* service.list({ state: "open" });
		2316	assert.deepStrictEqual(
		2317	first.entries.map((entry) => entry.number),
		2318	[1],
		2319	);
		2320
		2321	yield* TestClock.adjust("31 seconds");
		2322	const refreshed = yield* service.list({ state: "open" });
		2323
		2324	assert.strictEqual(hostCalls, 2);
		2325	assert.deepStrictEqual(
		2326	refreshed.entries.map((entry) => entry.number),
		2327	[2],
		2328	);
		2329	}),
		2330	);
		2331
2295	it.effect("a listing narrowed to some projects is its own cache entry", () =>	2332	it.effect("a listing narrowed to some projects is its own cache entry", () =>
2296	Effect.gen(function* () {	2333	Effect.gen(function* () {
2297	const asked: ReadonlyArray<string>[] = [];	2334	const asked: ReadonlyArray<string>[] = [];

apps/server/src/pullRequest/PullRequestService.ts+14-51

 @@ -102,16 +102,7 @@ const DIFF_CACHE_TTL = Duration.seconds(60);
 const COMMIT_DIFF_CACHE_TTL = Duration.minutes(10);
 /** Sized like the client's own stale time; a row's counts move only when somebody pushes. */
 const LIST_STATS_CACHE_TTL = Duration.seconds(60);
-/**
+/** A diff can stay interactive while its next cached value is fetched off the critical path. */
- * How long a cache's last success may still be served while a fresh read runs behind it.
- * Bounded by how the page actually revalidates: clients re-read on mount and once a minute
- * while open, and every one of those reads repopulates the cache in the background — so in
- * steady use a "stale" answer is at most a refresh cycle old, and the window only stretches
- * that far when nobody has looked at the page for minutes. An explicit refresh or a mutation
- * bumps the epochs and skips held answers entirely.
- */
-const LIST_STALE_WINDOW = Duration.minutes(10);
-const DETAIL_STALE_WINDOW = Duration.minutes(5);
 const DIFF_STALE_WINDOW = Duration.minutes(10);
 /** How long one host's signed-in login is believed without asking its CLI again. */
 const VIEWER_CACHE_TTL = Duration.minutes(10);
 @@ -1826,30 +1817,22 @@ export const make = Effect.gen(function* () {
   const runFork = Effect.runForkWith(context);
   /**
-   * Stale answers served while a fresh one is fetched behind them. Every read here leaves the
+   * The diff is not live-polled and is expensive enough to keep its stale-while-revalidate path.
-   * process for a CLI whose wall clock is the host's — seconds on a good day, tens of them on a
+   * Explicit refreshes and mutations still strand held values through the reference epoch.
-   * slow network — and the short cache windows below mean almost every page visit pays that
-   * clock again. The last success per key is therefore held a while longer: a read inside the
-   * window answers with it at once and refreshes the cache in the background, so the next read
-   * is fresh without anyone having waited on it.
-   *
-   * Correctness leans on the epochs: an explicit refresh or a mutation bumps them, the epoch is
-   * part of every key, and a held answer under the old key is simply never asked for again — so
-   * "give me truly fresh" still means exactly that.
    */
-  const staleWhileRevalidate = <A>(staleFor: Duration.Duration, capacity: number) => {
+  const staleDiff = (() => {
-    const staleMs = Duration.toMillis(staleFor);
+    const staleMs = Duration.toMillis(DIFF_STALE_WINDOW);
-    const held = new Map<string, { readonly at: number; readonly value: A }>();
+    const held = new Map<string, { readonly at: number; readonly value: PullRequestDiffResult }>();
-    const record = (key: string, value: A) =>
+    const record = (key: string, value: PullRequestDiffResult) =>
       Effect.map(Clock.currentTimeMillis, (at) => {
         held.delete(key);
-        if (held.size >= capacity) {
+        if (held.size >= DIFF_CACHE_CAPACITY) {
           const oldest = held.keys().next().value;
           if (oldest !== undefined) held.delete(oldest);
         }
         held.set(key, { at, value });
       });
-    return <E>(key: string, read: Effect.Effect<A, E>): Effect.Effect<A, E> => {
+    return <E>(key: string, read: Effect.Effect<PullRequestDiffResult, E>) => {
       const recorded = read.pipe(Effect.tap((value) => record(key, value)));
       return Effect.flatMap(Clock.currentTimeMillis, (now) => {
         const snapshot = held.get(key);
 @@ -1860,7 +1843,7 @@ export const make = Effect.gen(function* () {
         return Effect.sync(() => runFork(Effect.ignore(recorded))).pipe(Effect.as(snapshot.value));
       });
     };
-  };
+  })();
   // Epochs are the invalidation mechanism: a key carries its scope's epoch, so bumping the
   // epoch strands every entry made under the old one — no enumerating a cache whose keys
 @@ -1946,10 +1929,6 @@ export const make = Effect.gen(function* () {
       timeToLive: (exit) => (Exit.isSuccess(exit) ? LIST_CACHE_TTL : Duration.zero),
     },
   );
-  const staleList = staleWhileRevalidate<PullRequestListResult>(
-    LIST_STALE_WINDOW,
-    LIST_CACHE_CAPACITY,
-  );
   const list: PullRequestService["Service"]["list"] = (input) => {
     const key = JSON.stringify([
       listingsEpoch,
 @@ -1976,7 +1955,7 @@ export const make = Effect.gen(function* () {
         ? null
         : Object.entries(input.cursors).toSorted(([left], [right]) => left.localeCompare(right)),
     ]);
-    return staleList(key, Cache.get(listCache, key));
+    return Cache.get(listCache, key);
   };
   const detailCache = yield* Cache.makeWith(
 @@ -1989,13 +1968,9 @@ export const make = Effect.gen(function* () {
       timeToLive: (exit) => (Exit.isSuccess(exit) ? DETAIL_CACHE_TTL : Duration.zero),
     },
   );
-  const staleDetail = staleWhileRevalidate<PullRequestDetail>(
-    DETAIL_STALE_WINDOW,
-    DETAIL_CACHE_CAPACITY,
-  );
   const detail: PullRequestService["Service"]["detail"] = (input) => {
     const key = JSON.stringify([refEpoch(input), input.projectId, input.repository, input.number]);
-    return staleDetail(key, Cache.get(detailCache, key));
+    return Cache.get(detailCache, key);
   };
   const activityCache = yield* Cache.makeWith(
 @@ -2008,13 +1983,9 @@ export const make = Effect.gen(function* () {
       timeToLive: (exit) => (Exit.isSuccess(exit) ? DETAIL_CACHE_TTL : Duration.zero),
     },
   );
-  const staleActivity = staleWhileRevalidate<PullRequestActivity>(
-    DETAIL_STALE_WINDOW,
-    DETAIL_CACHE_CAPACITY,
-  );
   const activity: PullRequestService["Service"]["activity"] = (input) => {
     const key = JSON.stringify([refEpoch(input), input.projectId, input.repository, input.number]);
-    return staleActivity(key, Cache.get(activityCache, key));
+    return Cache.get(activityCache, key);
   };
   const diffCache = yield* Cache.makeWith(
 @@ -2044,10 +2015,6 @@ export const make = Effect.gen(function* () {
       },
     },
   );
-  const staleDiff = staleWhileRevalidate<PullRequestDiffResult>(
-    DIFF_STALE_WINDOW,
-    DIFF_CACHE_CAPACITY,
-  );
   const diff: PullRequestService["Service"]["diff"] = (input) => {
     const key = JSON.stringify([
       refEpoch(input),
 @@ -2076,10 +2043,6 @@ export const make = Effect.gen(function* () {
   // shares between clients like every other read. Refs are sorted so one page's worth of rows
   // is one key however the client assembled them, and the listings epoch rides along so the
   // refresh that forgets the listing forgets its decorations with it.
-  const staleListStats = staleWhileRevalidate<PullRequestListStatsResult>(
-    LIST_STALE_WINDOW,
-    LIST_STATS_CACHE_CAPACITY,
-  );
   const listStats: PullRequestService["Service"]["listStats"] = (input) => {
     if (input.refs.length === 0) return Effect.succeed({ stats: [] });
     const key = JSON.stringify([
 @@ -2090,7 +2053,7 @@ export const make = Effect.gen(function* () {
           `${left[0]} ${left[1]} ${left[2]}`.localeCompare(`${right[0]} ${right[1]} ${right[2]}`),
         ),
     ]);
-    return staleListStats(key, Cache.get(listStatsCache, key));
+    return Cache.get(listStatsCache, key);
   };
   const invalidate: PullRequestService["Service"]["invalidate"] = (input) =>