Skip to content

Commit 3cdc504

Browse files
fix(server): linked projects keep their repository identity while it refreshes (pingdotgg#32359)
Co-authored-by: Claude Opus 5.5 <[email protected]>
1 parent cfb7cae commit 3cdc504

2 files changed

Lines changed: 177 additions & 3 deletions

File tree

‎apps/server/src/project/ProjectEnrichmentService.test.ts‎

Lines changed: 131 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,13 @@
11
import { assert, it } from "@effect/vitest";
22
import type { RepositoryIdentity } from "@t3tools/contracts";
33
import * as Deferred from "effect/Deferred";
4+
import * as Duration from "effect/Duration";
45
import * as Effect from "effect/Effect";
6+
import * as Fiber from "effect/Fiber";
57
import * as Layer from "effect/Layer";
68
import * as PubSub from "effect/PubSub";
79
import * as Ref from "effect/Ref";
10+
import * as TestClock from "effect/testing/TestClock";
811

912
import * as ProjectEnrichment from "./ProjectEnrichmentService.ts";
1013
import * as ProjectFaviconResolver from "./ProjectFaviconResolver.ts";
@@ -257,3 +260,131 @@ it.effect("deduplicates requests, bounds pending work, and reloads invalidated r
257260
);
258261
}),
259262
);
263+
264+
it.effect(
265+
"keeps the last resolved repository identity after it expires and while it refreshes",
266+
() =>
267+
Effect.gen(function* () {
268+
const refreshStarted = yield* Deferred.make<void>();
269+
const releaseRefresh = yield* Deferred.make<void>();
270+
const resolveCalls = yield* Ref.make(0);
271+
const layerMetadata = Layer.merge(
272+
Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
273+
resolve: (workspaceRoot) =>
274+
Effect.gen(function* () {
275+
if ((yield* Ref.updateAndGet(resolveCalls, (count) => count + 1)) > 1) {
276+
yield* Deferred.succeed(refreshStarted, undefined);
277+
yield* Deferred.await(releaseRefresh);
278+
}
279+
return identity(workspaceRoot);
280+
}),
281+
}),
282+
Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
283+
invalidate: () => Effect.void,
284+
resolvePath: () => Effect.succeed(null),
285+
}),
286+
);
287+
288+
yield* Effect.gen(function* () {
289+
const service = yield* ProjectEnrichment.ProjectEnrichmentService;
290+
const changes = yield* service.subscribeChanges;
291+
yield* service.request("/widgets");
292+
const resolved = yield* PubSub.take(changes);
293+
assert.equal(
294+
resolved.enrichment.repositoryIdentity?.canonicalKey,
295+
"example.test/v1/widgets",
296+
);
297+
298+
yield* TestClock.adjust(Duration.seconds(61));
299+
300+
const expired = yield* service.getAvailable("/widgets");
301+
assert.equal(
302+
expired.repositoryIdentity?.canonicalKey,
303+
"example.test/v1/widgets",
304+
"an expired repository identity should still be returned until a refresh replaces it",
305+
);
306+
307+
yield* Deferred.await(refreshStarted);
308+
const refreshing = yield* service.peek("/widgets");
309+
assert.equal(
310+
refreshing.repositoryIdentity?.canonicalKey,
311+
"example.test/v1/widgets",
312+
"a repository identity should still be returned while its refresh is pending",
313+
);
314+
}).pipe(Effect.provide(layer(layerMetadata)));
315+
}),
316+
);
317+
318+
it.effect("does not let a lookup invalidated mid-flight replace a newer last identity", () =>
319+
Effect.gen(function* () {
320+
const firstStarted = yield* Deferred.make<void>();
321+
const releaseFirst = yield* Deferred.make<void>();
322+
const resolveCalls = yield* Ref.make(0);
323+
const layerMetadata = Layer.merge(
324+
Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
325+
resolve: (workspaceRoot) =>
326+
Effect.gen(function* () {
327+
const call = yield* Ref.updateAndGet(resolveCalls, (count) => count + 1);
328+
if (call === 1) {
329+
yield* Deferred.succeed(firstStarted, undefined);
330+
yield* Deferred.await(releaseFirst);
331+
}
332+
return identity(workspaceRoot, call);
333+
}),
334+
}),
335+
Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
336+
invalidate: () => Effect.void,
337+
resolvePath: () => Effect.succeed(null),
338+
}),
339+
);
340+
341+
yield* Effect.gen(function* () {
342+
const service = yield* ProjectEnrichment.ProjectEnrichmentService;
343+
const firstLookup = yield* Effect.forkChild(service.readRepositoryIdentity("/widgets"));
344+
yield* Deferred.await(firstStarted);
345+
yield* service.invalidate(["/widgets"]);
346+
const newer = yield* service.readRepositoryIdentity("/widgets");
347+
assert.equal(newer?.canonicalKey, "example.test/v2/widgets");
348+
349+
yield* Deferred.succeed(releaseFirst, undefined);
350+
yield* Fiber.join(firstLookup);
351+
yield* TestClock.adjust(Duration.seconds(61));
352+
353+
const expired = yield* service.peek("/widgets");
354+
assert.equal(expired.repositoryIdentity?.canonicalKey, "example.test/v2/widgets");
355+
}).pipe(Effect.provide(layer(layerMetadata)));
356+
}),
357+
);
358+
359+
it.effect("keeps a lookup's identity when another root is invalidated mid-flight", () =>
360+
Effect.gen(function* () {
361+
const started = yield* Deferred.make<void>();
362+
const release = yield* Deferred.make<void>();
363+
const layerMetadata = Layer.merge(
364+
Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
365+
resolve: (workspaceRoot) =>
366+
Deferred.succeed(started, undefined).pipe(
367+
Effect.andThen(Deferred.await(release)),
368+
Effect.as(identity(workspaceRoot)),
369+
),
370+
}),
371+
Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
372+
invalidate: () => Effect.void,
373+
resolvePath: () => Effect.succeed(null),
374+
}),
375+
);
376+
377+
yield* Effect.gen(function* () {
378+
const service = yield* ProjectEnrichment.ProjectEnrichmentService;
379+
const lookup = yield* Effect.forkChild(service.readRepositoryIdentity("/widgets"));
380+
yield* Deferred.await(started);
381+
yield* service.invalidate(["/other"]);
382+
yield* Deferred.succeed(release, undefined);
383+
yield* Fiber.join(lookup);
384+
yield* TestClock.adjust(Duration.seconds(61));
385+
386+
const expired = yield* service.peek("/widgets");
387+
assert.equal(expired.repositoryIdentity?.canonicalKey, "example.test/v1/widgets");
388+
}).pipe(Effect.provide(layer(layerMetadata)));
389+
}),
390+
);

‎apps/server/src/project/ProjectEnrichmentService.ts‎

Lines changed: 46 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -91,8 +91,44 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
9191
const maxPending = Math.max(1, options.maxPending ?? DEFAULT_MAX_PENDING);
9292
const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY);
9393

94+
// Outlives the cache entry so an expired or refreshing identity still reads as its last value.
95+
const lastRepositoryIdentities = new Map<string, RepositoryIdentity>();
96+
// `invalidate` drops a root's in-flight lookup so its late result cannot overwrite a newer one.
97+
const lookupsInFlight = new Map<string, object>();
98+
const rememberRepositoryIdentity = (
99+
workspaceRoot: string,
100+
repositoryIdentity: RepositoryIdentity | null,
101+
) => {
102+
lastRepositoryIdentities.delete(workspaceRoot);
103+
if (repositoryIdentity === null) return;
104+
if (lastRepositoryIdentities.size >= cacheCapacity) {
105+
const oldestRoot = lastRepositoryIdentities.keys().next().value;
106+
if (oldestRoot !== undefined) lastRepositoryIdentities.delete(oldestRoot);
107+
}
108+
lastRepositoryIdentities.set(workspaceRoot, repositoryIdentity);
109+
};
110+
94111
const repositoryIdentityCache = yield* Cache.makeWith(
95-
(workspaceRoot: string) => Effect.exit(repositoryIdentityResolver.resolve(workspaceRoot)),
112+
(workspaceRoot: string) =>
113+
Effect.suspend(() => {
114+
const lookup = {};
115+
lookupsInFlight.set(workspaceRoot, lookup);
116+
const isCurrent = () => lookupsInFlight.get(workspaceRoot) === lookup;
117+
return Effect.exit(repositoryIdentityResolver.resolve(workspaceRoot)).pipe(
118+
Effect.tap((result) =>
119+
Effect.sync(() => {
120+
if (Exit.isSuccess(result) && isCurrent()) {
121+
rememberRepositoryIdentity(workspaceRoot, result.value);
122+
}
123+
}),
124+
),
125+
Effect.ensuring(
126+
Effect.sync(() => {
127+
if (isCurrent()) lookupsInFlight.delete(workspaceRoot);
128+
}),
129+
),
130+
);
131+
}),
96132
{
97133
capacity: cacheCapacity,
98134
timeToLive: Exit.match({
@@ -238,10 +274,13 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
238274
] as const,
239275
{ concurrency: "unbounded" },
240276
);
277+
const repositoryIdentityResolved = isSuccessfullyResolved(repositoryIdentity);
241278
return {
242-
repositoryIdentity: availableValue(repositoryIdentity),
279+
repositoryIdentity: repositoryIdentityResolved
280+
? availableValue(repositoryIdentity)
281+
: (lastRepositoryIdentities.get(workspaceRoot) ?? null),
243282
faviconPath: availableValue(faviconPath),
244-
repositoryIdentityResolved: isSuccessfullyResolved(repositoryIdentity),
283+
repositoryIdentityResolved,
245284
};
246285
},
247286
);
@@ -287,6 +326,10 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
287326
Effect.all(
288327
[
289328
Cache.invalidate(repositoryIdentityCache, workspaceRoot),
329+
Effect.sync(() => {
330+
lookupsInFlight.delete(workspaceRoot);
331+
lastRepositoryIdentities.delete(workspaceRoot);
332+
}),
290333
Cache.invalidate(faviconCache, workspaceRoot),
291334
// The resolver keeps its own misses, which would outlive a clone filling the folder.
292335
faviconResolver.invalidate(workspaceRoot),

0 commit comments

Comments
 (0)