@decocms/blocks 7.86.4 → 7.86.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +3 -2
- package/src/cms/inflightCancelledOwner.test.ts +138 -0
- package/src/cms/resolve.ts +45 -26
- package/src/cms/sectionLoaders.ts +57 -11
- package/src/sdk/cacheStorage.test.ts +24 -0
- package/src/sdk/cacheStorage.ts +17 -10
- package/src/sdk/cachedLoader.ts +18 -8
- package/src/sdk/fetchCache.test.ts +75 -0
- package/src/sdk/fetchCache.ts +27 -3
- package/src/sdk/inflightTimeout.test.ts +27 -1
- package/src/sdk/inflightTimeout.ts +9 -5
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@decocms/blocks",
|
|
3
|
-
"version": "7.86.
|
|
3
|
+
"version": "7.86.6",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"engines": {
|
|
6
6
|
"node": ">=24"
|
|
@@ -59,6 +59,7 @@
|
|
|
59
59
|
"./sdk/env": "./src/sdk/env.ts",
|
|
60
60
|
"./sdk/fetchCache": "./src/sdk/fetchCache.ts",
|
|
61
61
|
"./sdk/fetchTimeout": "./src/sdk/fetchTimeout.ts",
|
|
62
|
+
"./sdk/inflightTimeout": "./src/sdk/inflightTimeout.ts",
|
|
62
63
|
"./sdk/experiments": "./src/sdk/experiments.ts",
|
|
63
64
|
"./sdk/flags": "./src/sdk/flags.ts",
|
|
64
65
|
"./sdk/http": "./src/sdk/http.ts",
|
|
@@ -115,7 +116,7 @@
|
|
|
115
116
|
"devDependencies": {
|
|
116
117
|
"@types/react": "^19.0.0",
|
|
117
118
|
"@types/react-dom": "^19.0.0",
|
|
118
|
-
"esbuild": "^0.
|
|
119
|
+
"esbuild": "^0.28.2",
|
|
119
120
|
"knip": "^5.86.0",
|
|
120
121
|
"typescript": "^5.9.0"
|
|
121
122
|
},
|
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Cancelled-owner regression for the module-level single-flight maps in
|
|
3
|
+
* sectionLoaders.ts (`layoutInflight`, `sectionLoaderInflight`) and resolve.ts
|
|
4
|
+
* (`resolvedLayoutInflight`).
|
|
5
|
+
*
|
|
6
|
+
* On Workers, when the client of the request that OWNS a shared flight
|
|
7
|
+
* disconnects, the runtime cancels that request's I/O and timers — including
|
|
8
|
+
* the owner's `withInflightTimeout`. The flight never settles and every later
|
|
9
|
+
* request for the same key used to hang for the life of the isolate (CPU ~0,
|
|
10
|
+
* wall 100s → 524). Simulated here: the owner's work never settles and
|
|
11
|
+
* `withInflightTimeout` is a pass-through (its timer "died" with the owner).
|
|
12
|
+
* Joiners must recover on their own timer.
|
|
13
|
+
*/
|
|
14
|
+
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
15
|
+
|
|
16
|
+
vi.mock("../sdk/inflightTimeout", async (importActual) => ({
|
|
17
|
+
...(await importActual<typeof import("../sdk/inflightTimeout")>()),
|
|
18
|
+
withInflightTimeout: <T>(work: Promise<T>) => work,
|
|
19
|
+
}));
|
|
20
|
+
|
|
21
|
+
import { bindCacheStorage } from "../sdk/cacheStorage";
|
|
22
|
+
import { RequestContext } from "../sdk/requestContext";
|
|
23
|
+
import {
|
|
24
|
+
registerCacheableSections,
|
|
25
|
+
registerLayoutSections,
|
|
26
|
+
registerSectionLoader,
|
|
27
|
+
registerSections,
|
|
28
|
+
resolveDecoPage,
|
|
29
|
+
runSingleSectionLoader,
|
|
30
|
+
setBlocks,
|
|
31
|
+
unregisterLayoutSections,
|
|
32
|
+
} from "./index";
|
|
33
|
+
import type { ResolvedSection } from "./resolve";
|
|
34
|
+
|
|
35
|
+
const section = (component: string, index: number): ResolvedSection =>
|
|
36
|
+
({ component, props: {}, key: `${component}-${index}`, index }) as ResolvedSection;
|
|
37
|
+
|
|
38
|
+
/** First call never settles (owner's request was cancelled); later calls resolve. */
|
|
39
|
+
function deadThenAlive() {
|
|
40
|
+
let calls = 0;
|
|
41
|
+
const loader = vi.fn(async (props: Record<string, unknown>) => {
|
|
42
|
+
calls++;
|
|
43
|
+
if (calls === 1) return new Promise<Record<string, unknown>>(() => {});
|
|
44
|
+
return { ...props, run: calls };
|
|
45
|
+
});
|
|
46
|
+
return loader;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
afterEach(() => {
|
|
50
|
+
vi.useRealTimers();
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
describe("single-flight joiners of a cancelled owner do not hang", () => {
|
|
54
|
+
it("layout section: joiners rerun after their own timer and keep their own index", async () => {
|
|
55
|
+
vi.useFakeTimers();
|
|
56
|
+
const TYPE = "site/sections/CancelHeader.tsx";
|
|
57
|
+
const loader = deadThenAlive();
|
|
58
|
+
registerSectionLoader(TYPE, loader);
|
|
59
|
+
registerLayoutSections([TYPE]);
|
|
60
|
+
const request = new Request("https://store.com/p");
|
|
61
|
+
try {
|
|
62
|
+
void runSingleSectionLoader(section(TYPE, 0), request);
|
|
63
|
+
const joiners = [1, 2, 3, 4, 5].map((i) => runSingleSectionLoader(section(TYPE, i), request));
|
|
64
|
+
await vi.advanceTimersByTimeAsync(10_000);
|
|
65
|
+
const results = await Promise.all(joiners);
|
|
66
|
+
|
|
67
|
+
expect(results.map((r) => r.index)).toEqual([1, 2, 3, 4, 5]);
|
|
68
|
+
expect(results.every((r) => (r.props as { run?: number }).run === 2)).toBe(true);
|
|
69
|
+
expect(loader).toHaveBeenCalledTimes(2);
|
|
70
|
+
} finally {
|
|
71
|
+
unregisterLayoutSections([TYPE]);
|
|
72
|
+
}
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
it("cacheable section: joiners rerun after their own timer instead of hanging", async () => {
|
|
76
|
+
vi.useFakeTimers();
|
|
77
|
+
const TYPE = "site/sections/CancelShelf.tsx";
|
|
78
|
+
const loader = deadThenAlive();
|
|
79
|
+
registerSectionLoader(TYPE, loader);
|
|
80
|
+
registerCacheableSections({ [TYPE]: { maxAge: 60_000 } });
|
|
81
|
+
const request = new Request("https://store.com/p");
|
|
82
|
+
|
|
83
|
+
void runSingleSectionLoader(section(TYPE, 0), request);
|
|
84
|
+
const joiners = [1, 2, 3].map((i) => runSingleSectionLoader(section(TYPE, i), request));
|
|
85
|
+
await vi.advanceTimersByTimeAsync(10_000);
|
|
86
|
+
const results = await Promise.all(joiners);
|
|
87
|
+
|
|
88
|
+
expect(results.every((r) => (r.props as { run?: number }).run === 2)).toBe(true);
|
|
89
|
+
expect(loader).toHaveBeenCalledTimes(2);
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
it("resolved layout (Header/Footer in resolveDecoPage): a page joining a dead flight still resolves", async () => {
|
|
93
|
+
vi.useFakeTimers();
|
|
94
|
+
const FOOTER = "site/sections/CancelFooter.tsx";
|
|
95
|
+
let imports = 0;
|
|
96
|
+
registerSections({
|
|
97
|
+
[FOOTER]: () => {
|
|
98
|
+
imports++;
|
|
99
|
+
return imports === 1 ? new Promise(() => {}) : Promise.resolve({ default: () => null });
|
|
100
|
+
},
|
|
101
|
+
});
|
|
102
|
+
registerLayoutSections([FOOTER]);
|
|
103
|
+
setBlocks({
|
|
104
|
+
"pages-cancel-a": { path: "/cancel-a", sections: [{ __resolveType: FOOTER }] },
|
|
105
|
+
"pages-cancel-b": { path: "/cancel-b", sections: [{ __resolveType: FOOTER }] },
|
|
106
|
+
});
|
|
107
|
+
try {
|
|
108
|
+
void resolveDecoPage("/cancel-a");
|
|
109
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
110
|
+
const joiner = resolveDecoPage("/cancel-b");
|
|
111
|
+
await vi.advanceTimersByTimeAsync(10_000);
|
|
112
|
+
const page = await joiner;
|
|
113
|
+
|
|
114
|
+
expect(page?.resolvedSections.some((s) => s.component === FOOTER)).toBe(true);
|
|
115
|
+
expect(imports).toBeGreaterThanOrEqual(2);
|
|
116
|
+
} finally {
|
|
117
|
+
unregisterLayoutSections([FOOTER]);
|
|
118
|
+
}
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
it("the owner's shared work is handed to ctx.waitUntil so a client disconnect does not kill it", async () => {
|
|
122
|
+
const TYPE = "site/sections/WaitUntilHeader.tsx";
|
|
123
|
+
registerSectionLoader(TYPE, async (p: Record<string, unknown>) => p);
|
|
124
|
+
registerLayoutSections([TYPE]);
|
|
125
|
+
const request = new Request("https://store.com/p");
|
|
126
|
+
const waitUntil = vi.fn();
|
|
127
|
+
try {
|
|
128
|
+
await RequestContext.run(request, async () => {
|
|
129
|
+
bindCacheStorage({ storage: null, scope: "test", waitUntil });
|
|
130
|
+
await runSingleSectionLoader(section(TYPE, 0), request);
|
|
131
|
+
});
|
|
132
|
+
expect(waitUntil).toHaveBeenCalled();
|
|
133
|
+
expect(waitUntil.mock.calls[0][0]).toBeInstanceOf(Promise);
|
|
134
|
+
} finally {
|
|
135
|
+
unregisterLayoutSections([TYPE]);
|
|
136
|
+
}
|
|
137
|
+
});
|
|
138
|
+
});
|
package/src/cms/resolve.ts
CHANGED
|
@@ -1,11 +1,11 @@
|
|
|
1
1
|
import { getMatchersOverride, getRuleOverrideId, hasMatchersOverride } from "../matchers/override";
|
|
2
2
|
import { getMeter, MetricNames, withTracing } from "../middleware/observability";
|
|
3
|
-
import { createCacheStore } from "../sdk/cacheStorage";
|
|
3
|
+
import { cacheBackground, createCacheStore } from "../sdk/cacheStorage";
|
|
4
4
|
import { detectDevice } from "../sdk/detectDevice";
|
|
5
5
|
import { djb2Hex } from "../sdk/djb2";
|
|
6
6
|
import { stickyDecide } from "../sdk/experiments";
|
|
7
7
|
import { parseSegmentCookie, SEGMENT_COOKIE, type StoredFlag, trafficToPct } from "../sdk/flags";
|
|
8
|
-
import { withInflightTimeout } from "../sdk/inflightTimeout";
|
|
8
|
+
import { joinInflight, withInflightTimeout } from "../sdk/inflightTimeout";
|
|
9
9
|
import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
|
|
10
10
|
import { stripTrackingParams } from "../sdk/urlUtils";
|
|
11
11
|
import {
|
|
@@ -1274,6 +1274,47 @@ interface ResolvedSectionsCache {
|
|
|
1274
1274
|
const resolvedLayoutCache = createCacheStore<ResolvedSectionsCache>("resolved-layouts");
|
|
1275
1275
|
const resolvedLayoutInflight = new Map<string, Promise<ResolvedSection[]>>();
|
|
1276
1276
|
|
|
1277
|
+
/**
|
|
1278
|
+
* Single-flight for resolved layouts (Header/Footer — every page joins it).
|
|
1279
|
+
* A slot whose owner request was cancelled never settles (its I/O and its
|
|
1280
|
+
* `withInflightTimeout` timer die with that request), so joiners are bounded
|
|
1281
|
+
* by their own timer (`joinInflight`), the owner's work is kept alive with
|
|
1282
|
+
* `waitUntil` (`cacheBackground`) and the slot is released by identity.
|
|
1283
|
+
*/
|
|
1284
|
+
function sharedResolvedLayout(
|
|
1285
|
+
cacheKey: string,
|
|
1286
|
+
run: () => Promise<ResolvedSection[]>,
|
|
1287
|
+
): Promise<ResolvedSection[]> {
|
|
1288
|
+
const inflight = resolvedLayoutInflight.get(cacheKey);
|
|
1289
|
+
if (inflight) {
|
|
1290
|
+
return joinInflight(
|
|
1291
|
+
inflight,
|
|
1292
|
+
() => {
|
|
1293
|
+
if (resolvedLayoutInflight.get(cacheKey) === inflight)
|
|
1294
|
+
resolvedLayoutInflight.delete(cacheKey);
|
|
1295
|
+
// A newer flight may have filled the cache while this one stalled.
|
|
1296
|
+
return getCachedResolvedLayout(cacheKey).then(
|
|
1297
|
+
(cached) => cached ?? sharedResolvedLayout(cacheKey, run),
|
|
1298
|
+
);
|
|
1299
|
+
},
|
|
1300
|
+
undefined,
|
|
1301
|
+
`resolvedLayout ${cacheKey}`,
|
|
1302
|
+
);
|
|
1303
|
+
}
|
|
1304
|
+
const p: Promise<ResolvedSection[]> = withInflightTimeout(
|
|
1305
|
+
run().then((results) => {
|
|
1306
|
+
setCachedResolvedLayout(cacheKey, results);
|
|
1307
|
+
return results;
|
|
1308
|
+
}),
|
|
1309
|
+
`resolvedLayout ${cacheKey}`,
|
|
1310
|
+
).finally(() => {
|
|
1311
|
+
if (resolvedLayoutInflight.get(cacheKey) === p) resolvedLayoutInflight.delete(cacheKey);
|
|
1312
|
+
});
|
|
1313
|
+
cacheBackground(p);
|
|
1314
|
+
resolvedLayoutInflight.set(cacheKey, p);
|
|
1315
|
+
return p;
|
|
1316
|
+
}
|
|
1317
|
+
|
|
1277
1318
|
/**
|
|
1278
1319
|
* Cache key for a resolved layout block, segmented by DEVICE.
|
|
1279
1320
|
*
|
|
@@ -2535,18 +2576,7 @@ async function resolveDecoPageImpl(
|
|
|
2535
2576
|
const cached = await getCachedResolvedLayout(cacheKey);
|
|
2536
2577
|
if (cached) return cached;
|
|
2537
2578
|
|
|
2538
|
-
|
|
2539
|
-
if (inflight) return inflight;
|
|
2540
|
-
|
|
2541
|
-
const p = withInflightTimeout(
|
|
2542
|
-
resolveRawSection(section, rctx).then((results) => {
|
|
2543
|
-
setCachedResolvedLayout(cacheKey, results);
|
|
2544
|
-
return results;
|
|
2545
|
-
}),
|
|
2546
|
-
`resolvedLayout ${cacheKey}`,
|
|
2547
|
-
).finally(() => resolvedLayoutInflight.delete(cacheKey));
|
|
2548
|
-
resolvedLayoutInflight.set(cacheKey, p);
|
|
2549
|
-
return p;
|
|
2579
|
+
return sharedResolvedLayout(cacheKey, () => resolveRawSection(section, rctx));
|
|
2550
2580
|
}
|
|
2551
2581
|
|
|
2552
2582
|
return resolveRawSection(section, rctx);
|
|
@@ -2641,18 +2671,7 @@ export async function resolvePageSections(
|
|
|
2641
2671
|
const cached = await getCachedResolvedLayout(cacheKey);
|
|
2642
2672
|
if (cached) return cached;
|
|
2643
2673
|
|
|
2644
|
-
|
|
2645
|
-
if (inflight) return inflight;
|
|
2646
|
-
|
|
2647
|
-
const p = withInflightTimeout(
|
|
2648
|
-
resolveRawSection(section, rctx).then((results) => {
|
|
2649
|
-
setCachedResolvedLayout(cacheKey, results);
|
|
2650
|
-
return results;
|
|
2651
|
-
}),
|
|
2652
|
-
`resolvedLayout ${cacheKey}`,
|
|
2653
|
-
).finally(() => resolvedLayoutInflight.delete(cacheKey));
|
|
2654
|
-
resolvedLayoutInflight.set(cacheKey, p);
|
|
2655
|
-
return p;
|
|
2674
|
+
return sharedResolvedLayout(cacheKey, () => resolveRawSection(section, rctx));
|
|
2656
2675
|
}
|
|
2657
2676
|
|
|
2658
2677
|
return resolveRawSection(section, rctx);
|
|
@@ -13,7 +13,46 @@ import { RequestContext } from "@decocms/blocks/sdk/requestContext";
|
|
|
13
13
|
import { getCacheProfile } from "../sdk/cacheHeaders";
|
|
14
14
|
import { cacheBackground, createCacheStore, getCacheStorageContext } from "../sdk/cacheStorage";
|
|
15
15
|
import { detectDevice } from "../sdk/detectDevice";
|
|
16
|
-
import { withInflightTimeout } from "../sdk/inflightTimeout";
|
|
16
|
+
import { joinInflight, withInflightTimeout } from "../sdk/inflightTimeout";
|
|
17
|
+
|
|
18
|
+
/**
|
|
19
|
+
* A slot whose owner request was cancelled never settles: its I/O and its
|
|
20
|
+
* `withInflightTimeout` timer die with that request. Joiners are bounded by
|
|
21
|
+
* their own timer (`joinInflight`), the owner's work is kept alive with
|
|
22
|
+
* `waitUntil` (`cacheBackground`), and the slot is released by identity so a
|
|
23
|
+
* late `finally` never evicts a newer flight. Same pair `cachedLoader` uses.
|
|
24
|
+
*/
|
|
25
|
+
function joinSlot<T>(
|
|
26
|
+
map: Map<string, Promise<T>>,
|
|
27
|
+
key: string,
|
|
28
|
+
shared: Promise<T>,
|
|
29
|
+
rerun: () => Promise<T>,
|
|
30
|
+
label: string,
|
|
31
|
+
): Promise<T> {
|
|
32
|
+
return joinInflight(
|
|
33
|
+
shared,
|
|
34
|
+
() => {
|
|
35
|
+
if (map.get(key) === shared) map.delete(key);
|
|
36
|
+
return rerun();
|
|
37
|
+
},
|
|
38
|
+
undefined,
|
|
39
|
+
label,
|
|
40
|
+
);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
function publishSlot<T>(
|
|
44
|
+
map: Map<string, Promise<T>>,
|
|
45
|
+
key: string,
|
|
46
|
+
promise: Promise<T>,
|
|
47
|
+
): Promise<T> {
|
|
48
|
+
const tracked: Promise<T> = promise.finally(() => {
|
|
49
|
+
if (map.get(key) === tracked) map.delete(key);
|
|
50
|
+
});
|
|
51
|
+
cacheBackground(tracked);
|
|
52
|
+
map.set(key, tracked);
|
|
53
|
+
return tracked;
|
|
54
|
+
}
|
|
55
|
+
|
|
17
56
|
import { withTracing } from "../sdk/observability";
|
|
18
57
|
import type { ResolvedSection } from "./resolve";
|
|
19
58
|
import { buildSectionLoaderContext, type SectionLoaderContext } from "./sectionLoaderContext";
|
|
@@ -145,14 +184,16 @@ async function runCacheableSectionLoader(
|
|
|
145
184
|
sectionCacheKey(section.component, section.props as Record<string, unknown>),
|
|
146
185
|
);
|
|
147
186
|
|
|
187
|
+
const rerun = () => runCacheableSectionLoader(section, loader, request, config);
|
|
148
188
|
const existing = sectionLoaderInflight.get(key);
|
|
149
|
-
if (existing)
|
|
189
|
+
if (existing)
|
|
190
|
+
return joinSlot(sectionLoaderInflight, key, existing, rerun, `sectionLoader ${key}`);
|
|
150
191
|
|
|
151
192
|
const entry = getCacheStorageContext()?.storage
|
|
152
193
|
? await sectionLoaderCache.read(key)
|
|
153
194
|
: sectionLoaderCache.get(key);
|
|
154
195
|
const pending = sectionLoaderInflight.get(key);
|
|
155
|
-
if (pending) return pending;
|
|
196
|
+
if (pending) return joinSlot(sectionLoaderInflight, key, pending, rerun, `sectionLoader ${key}`);
|
|
156
197
|
const now = Date.now();
|
|
157
198
|
const isStale = entry ? now - entry.createdAt > config.maxAge : true;
|
|
158
199
|
|
|
@@ -202,10 +243,9 @@ async function runCacheableSectionLoader(
|
|
|
202
243
|
return enriched;
|
|
203
244
|
})(),
|
|
204
245
|
`sectionLoader ${key}`,
|
|
205
|
-
)
|
|
246
|
+
);
|
|
206
247
|
|
|
207
|
-
sectionLoaderInflight
|
|
208
|
-
return promise;
|
|
248
|
+
return publishSlot(sectionLoaderInflight, key, promise);
|
|
209
249
|
}
|
|
210
250
|
|
|
211
251
|
/**
|
|
@@ -386,7 +426,15 @@ async function resolveLayoutSection(
|
|
|
386
426
|
if (cached) return Promise.resolve(withIndex(cached));
|
|
387
427
|
|
|
388
428
|
const existing = layoutInflight.get(key);
|
|
389
|
-
if (existing)
|
|
429
|
+
if (existing) {
|
|
430
|
+
return joinSlot(
|
|
431
|
+
layoutInflight,
|
|
432
|
+
key,
|
|
433
|
+
existing,
|
|
434
|
+
() => resolveLayoutSection(section, loader, request),
|
|
435
|
+
`layoutSection ${key}`,
|
|
436
|
+
).then(withIndex);
|
|
437
|
+
}
|
|
390
438
|
|
|
391
439
|
const promise = withInflightTimeout(
|
|
392
440
|
(async () => {
|
|
@@ -397,11 +445,9 @@ async function resolveLayoutSection(
|
|
|
397
445
|
return withIndex(enriched);
|
|
398
446
|
})(),
|
|
399
447
|
`layoutSection ${key}`,
|
|
400
|
-
)
|
|
401
|
-
|
|
402
|
-
layoutInflight.set(key, promise);
|
|
448
|
+
);
|
|
403
449
|
|
|
404
|
-
return promise;
|
|
450
|
+
return publishSlot(layoutInflight, key, promise);
|
|
405
451
|
}
|
|
406
452
|
|
|
407
453
|
/**
|
|
@@ -169,6 +169,30 @@ it("retains non-JSON values locally without silently corrupting them in KV", asy
|
|
|
169
169
|
});
|
|
170
170
|
});
|
|
171
171
|
|
|
172
|
+
it("serializes a cached value once per write and not at all on a storage hit", async () => {
|
|
173
|
+
const storage = createKVCacheStorage(fakeKV());
|
|
174
|
+
const value = { items: [{ id: 1 }, { id: 2 }] };
|
|
175
|
+
const stringify = vi.spyOn(JSON, "stringify");
|
|
176
|
+
const ofValue = () =>
|
|
177
|
+
stringify.mock.calls.filter(([v]) => v === value || (v as { value?: unknown })?.value === value)
|
|
178
|
+
.length;
|
|
179
|
+
const writer = createCacheStore<typeof value>("once");
|
|
180
|
+
await run(storage, "site", async () => {
|
|
181
|
+
writer.set(writer.key("k"), value, Date.now() + 60_000);
|
|
182
|
+
await flush();
|
|
183
|
+
});
|
|
184
|
+
expect(ofValue()).toBe(1);
|
|
185
|
+
stringify.mockClear();
|
|
186
|
+
const reader = createCacheStore<typeof value>("once");
|
|
187
|
+
const hit = await run(storage, "site", () => reader.read(reader.key("k")));
|
|
188
|
+
expect(hit).toEqual(value);
|
|
189
|
+
// Sizing the memory tier reuses the raw text it just parsed.
|
|
190
|
+
expect(
|
|
191
|
+
stringify.mock.calls.filter(([v]) => (v as { items?: unknown })?.items !== undefined),
|
|
192
|
+
).toHaveLength(0);
|
|
193
|
+
stringify.mockRestore();
|
|
194
|
+
});
|
|
195
|
+
|
|
172
196
|
it("deduplicates a cold loader through slow storage and survives a memory wipe", async () => {
|
|
173
197
|
const storage = createKVCacheStorage(fakeKV());
|
|
174
198
|
const fn = vi.fn(async () => ({ product: 42 }));
|
package/src/sdk/cacheStorage.ts
CHANGED
|
@@ -118,7 +118,10 @@ export function createKVCacheStorage(
|
|
|
118
118
|
if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) return;
|
|
119
119
|
const raw = JSON.stringify({ value, expiresAt });
|
|
120
120
|
// Leave space below KV's 25 MiB value limit. Oversized cache entries are optional.
|
|
121
|
-
|
|
121
|
+
// UTF-8 takes at most 3 bytes per UTF-16 unit, so only a value that long needs the
|
|
122
|
+
// exact count: encoding every write copied each entry once more just to measure it.
|
|
123
|
+
const limit = 25 * 1024 * 1024;
|
|
124
|
+
if (raw.length * 3 > limit && new TextEncoder().encode(raw).byteLength > limit) return;
|
|
122
125
|
await kv.put(await keyFor(key), raw, {
|
|
123
126
|
expirationTtl: Math.max(60, Math.ceil((expiresAt - Date.now()) / 1000)),
|
|
124
127
|
});
|
|
@@ -175,7 +178,9 @@ function serialize(value: unknown): string | undefined {
|
|
|
175
178
|
throw new Error("Unsupported cached object");
|
|
176
179
|
}
|
|
177
180
|
seen.add(v);
|
|
178
|
-
|
|
181
|
+
// Index and key loops: `Object.values` copied every array and object it walked.
|
|
182
|
+
if (Array.isArray(v)) for (let i = 0; i < v.length; i++) check(v[i]);
|
|
183
|
+
else for (const key in v) check((v as Record<string, unknown>)[key]);
|
|
179
184
|
seen.delete(v);
|
|
180
185
|
}
|
|
181
186
|
check(value);
|
|
@@ -203,13 +208,14 @@ export function createCacheStore<T>(
|
|
|
203
208
|
if (entry) bytes -= entry.bytes;
|
|
204
209
|
local.delete(key);
|
|
205
210
|
}
|
|
206
|
-
|
|
211
|
+
/** `json`: the value's serialization when the caller already has it, so sizing doesn't stringify again. */
|
|
212
|
+
function remember(key: string, value: T, expiresAt: number, json?: string) {
|
|
207
213
|
remove(key);
|
|
208
214
|
let size: number;
|
|
209
215
|
try {
|
|
210
216
|
size = sizeOf
|
|
211
217
|
? sizeOf(value)
|
|
212
|
-
: Math.max(512, (key.length + (JSON.stringify(value)?.length ?? 0)) * 2);
|
|
218
|
+
: Math.max(512, (key.length + ((json ?? JSON.stringify(value))?.length ?? 0)) * 2);
|
|
213
219
|
} catch {
|
|
214
220
|
size = 1024;
|
|
215
221
|
}
|
|
@@ -252,7 +258,7 @@ export function createCacheStore<T>(
|
|
|
252
258
|
if (raw === null) return undefined;
|
|
253
259
|
const entry = JSON.parse(raw) as { value: T; expiresAt: number };
|
|
254
260
|
if (!Number.isFinite(entry.expiresAt) || Date.now() >= entry.expiresAt) return undefined;
|
|
255
|
-
remember(key, entry.value, entry.expiresAt);
|
|
261
|
+
remember(key, entry.value, entry.expiresAt, raw);
|
|
256
262
|
return entry.value;
|
|
257
263
|
} catch {
|
|
258
264
|
return undefined;
|
|
@@ -265,15 +271,16 @@ export function createCacheStore<T>(
|
|
|
265
271
|
expiresAt <= Date.now()
|
|
266
272
|
)
|
|
267
273
|
return;
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
if (!persist || !storage || !Number.isFinite(expiresAt)) return;
|
|
274
|
+
const storage = persist ? getCacheStorageContext()?.storage : null;
|
|
275
|
+
let raw: string | undefined;
|
|
271
276
|
try {
|
|
272
|
-
|
|
273
|
-
if (raw !== undefined) cacheBackground(storage.set(key, raw, expiresAt));
|
|
277
|
+
if (storage) raw = serialize({ value, expiresAt });
|
|
274
278
|
} catch {
|
|
275
279
|
/* Non-serializable results remain in the memory tier. */
|
|
276
280
|
}
|
|
281
|
+
// The memory tier is sized from the same serialization the storage gets.
|
|
282
|
+
remember(key, value, expiresAt, raw);
|
|
283
|
+
if (storage && raw !== undefined) cacheBackground(storage.set(key, raw, expiresAt));
|
|
277
284
|
},
|
|
278
285
|
delete(key: string): void {
|
|
279
286
|
remove(key);
|
package/src/sdk/cachedLoader.ts
CHANGED
|
@@ -302,10 +302,15 @@ export function createCachedLoader<TProps, TResult>(
|
|
|
302
302
|
// request (see `joinInflight`): if the owner's request was cancelled and
|
|
303
303
|
// its Promise will never settle, evict the dead slot and run again.
|
|
304
304
|
const join = (shared: Promise<unknown>): Promise<TResult> =>
|
|
305
|
-
joinInflight(
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
305
|
+
joinInflight(
|
|
306
|
+
shared as Promise<TResult>,
|
|
307
|
+
() => {
|
|
308
|
+
releaseSlot(inflightRequests, cacheKey, shared);
|
|
309
|
+
return cachedFn(props);
|
|
310
|
+
},
|
|
311
|
+
undefined,
|
|
312
|
+
`cachedLoader ${cacheKey}`,
|
|
313
|
+
);
|
|
309
314
|
const retention =
|
|
310
315
|
maxAge +
|
|
311
316
|
Math.max(staleIfError, policy === "stale-while-revalidate" ? staleWhileRevalidate : 0);
|
|
@@ -549,10 +554,15 @@ export function createCachedLoaderFromModule<TProps, TResult>(
|
|
|
549
554
|
if (existing) {
|
|
550
555
|
// Bounded by this caller's own timer: a flight whose owner request was
|
|
551
556
|
// cancelled never settles — evict it and run again (see `joinInflight`).
|
|
552
|
-
return joinInflight(
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
557
|
+
return joinInflight(
|
|
558
|
+
existing,
|
|
559
|
+
() => {
|
|
560
|
+
releaseSlot(moduleInflight, key, existing);
|
|
561
|
+
return dedupedFn(props, req, ctx);
|
|
562
|
+
},
|
|
563
|
+
undefined,
|
|
564
|
+
`dedupLoader ${key}`,
|
|
565
|
+
);
|
|
556
566
|
}
|
|
557
567
|
|
|
558
568
|
const promise: Promise<TResult> = Promise.resolve(mod.default(props, req, ctx)).finally(() => {
|
|
@@ -204,3 +204,78 @@ describe("createFetchCache — shared storage scope", () => {
|
|
|
204
204
|
expect(await acrossDeploy(undefined)).toEqual({ body: { ok: true }, calls: 2 });
|
|
205
205
|
});
|
|
206
206
|
});
|
|
207
|
+
|
|
208
|
+
// Workers cancels a request's I/O AND timers when its client disconnects. A
|
|
209
|
+
// flight whose owner was cancelled never settles, so its own backstop timer
|
|
210
|
+
// never fires either — every caller that joined it used to hang for the life
|
|
211
|
+
// of the isolate (CPU ~0, wall 100s → 524). Simulated here: the owner's fetch
|
|
212
|
+
// never resolves and its timers are swallowed while it arms them.
|
|
213
|
+
describe("fetchCache — cancelled owner", () => {
|
|
214
|
+
it("a joiner recovers on its own timer instead of hanging on the dead slot", async () => {
|
|
215
|
+
const fc = createFetchCache({
|
|
216
|
+
provider: "cancelled-owner",
|
|
217
|
+
maxEntries: 10,
|
|
218
|
+
freshTtlMs: { success: 60_000, notFound: 0, serverError: 0 },
|
|
219
|
+
staleIfErrorMs: 0,
|
|
220
|
+
inflightBackstopMs: 100,
|
|
221
|
+
});
|
|
222
|
+
let calls = 0;
|
|
223
|
+
const doFetch = () =>
|
|
224
|
+
++calls === 1
|
|
225
|
+
? new Promise<Response>(() => {})
|
|
226
|
+
: Promise.resolve(Response.json({ ok: true }));
|
|
227
|
+
|
|
228
|
+
const realSetTimeout = globalThis.setTimeout;
|
|
229
|
+
(globalThis as { setTimeout: unknown }).setTimeout = () => 0;
|
|
230
|
+
try {
|
|
231
|
+
void fc.fetchWithCache("k", doFetch);
|
|
232
|
+
} finally {
|
|
233
|
+
globalThis.setTimeout = realSetTimeout;
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
const res = await Promise.race([
|
|
237
|
+
fc.fetchWithCache("k", doFetch),
|
|
238
|
+
new Promise((r) => setTimeout(() => r("HUNG"), 2_000)),
|
|
239
|
+
]);
|
|
240
|
+
expect(res).toEqual({ ok: true });
|
|
241
|
+
expect(calls).toBe(2);
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
it("a joiner that stalls is counted once, by its retry, not as a HIT too", async () => {
|
|
245
|
+
const { adapter, counters } = captureMeter();
|
|
246
|
+
configureMeter(adapter);
|
|
247
|
+
try {
|
|
248
|
+
const fc = createFetchCache({
|
|
249
|
+
provider: "stalled-joiner",
|
|
250
|
+
maxEntries: 10,
|
|
251
|
+
freshTtlMs: { success: 60_000, notFound: 0, serverError: 0 },
|
|
252
|
+
staleIfErrorMs: 0,
|
|
253
|
+
inflightBackstopMs: 100,
|
|
254
|
+
});
|
|
255
|
+
let calls = 0;
|
|
256
|
+
const doFetch = () =>
|
|
257
|
+
++calls === 1
|
|
258
|
+
? new Promise<Response>(() => {})
|
|
259
|
+
: Promise.resolve(Response.json({ ok: true }));
|
|
260
|
+
|
|
261
|
+
const realSetTimeout = globalThis.setTimeout;
|
|
262
|
+
(globalThis as { setTimeout: unknown }).setTimeout = () => 0;
|
|
263
|
+
try {
|
|
264
|
+
void fc.fetchWithCache("k", doFetch);
|
|
265
|
+
} finally {
|
|
266
|
+
globalThis.setTimeout = realSetTimeout;
|
|
267
|
+
}
|
|
268
|
+
counters.length = 0;
|
|
269
|
+
|
|
270
|
+
await fc.fetchWithCache("k", doFetch);
|
|
271
|
+
const decisions = counters
|
|
272
|
+
.filter(
|
|
273
|
+
(c) => c.name === "deco.cache.requests" && c.labels?.["provider"] === "stalled-joiner",
|
|
274
|
+
)
|
|
275
|
+
.map((c) => c.labels?.["status"]);
|
|
276
|
+
expect(decisions).toEqual(["MISS"]);
|
|
277
|
+
} finally {
|
|
278
|
+
configureMeter({ counterInc: () => {} });
|
|
279
|
+
}
|
|
280
|
+
});
|
|
281
|
+
});
|
package/src/sdk/fetchCache.ts
CHANGED
|
@@ -29,6 +29,7 @@
|
|
|
29
29
|
|
|
30
30
|
import { type CacheDecision, recordCacheMetric } from "../middleware/observability";
|
|
31
31
|
import { cacheBackground, createCacheStore, getCacheStorageContext } from "./cacheStorage";
|
|
32
|
+
import { joinInflight } from "./inflightTimeout";
|
|
32
33
|
|
|
33
34
|
/** Fresh-TTL (ms) by HTTP status class. See {@link FetchCacheConfig}. */
|
|
34
35
|
export interface FreshTtlByStatus {
|
|
@@ -171,6 +172,7 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
|
|
|
171
172
|
doFetch: () => Promise<Response>,
|
|
172
173
|
opts?: FetchCacheOptions,
|
|
173
174
|
): Promise<T | null> {
|
|
175
|
+
const inputKey = cacheKey;
|
|
174
176
|
cacheKey = store.key(cacheKey);
|
|
175
177
|
const entry = getCacheStorageContext()?.storage
|
|
176
178
|
? await store.read(cacheKey)
|
|
@@ -237,8 +239,25 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
|
|
|
237
239
|
const existing = inflight.get(cacheKey);
|
|
238
240
|
if (existing) {
|
|
239
241
|
// Joined an in-flight upstream fetch — no upstream call of our own.
|
|
240
|
-
|
|
241
|
-
|
|
242
|
+
// Bounded by THIS caller's timer: if the owner request was cancelled its
|
|
243
|
+
// fetch (and its backstop timer) died with it and `existing` never
|
|
244
|
+
// settles — evict the dead slot and fetch again (see `joinInflight`).
|
|
245
|
+
// The join counts as a HIT only when it is answered by the shared fetch:
|
|
246
|
+
// after a stall the retry records its own decision.
|
|
247
|
+
let stalled = false;
|
|
248
|
+
return joinInflight(
|
|
249
|
+
existing.then((e) => {
|
|
250
|
+
if (!stalled) emit("HIT");
|
|
251
|
+
return e.body as T | null;
|
|
252
|
+
}),
|
|
253
|
+
() => {
|
|
254
|
+
stalled = true;
|
|
255
|
+
if (inflight.get(cacheKey) === existing) inflight.delete(cacheKey);
|
|
256
|
+
return fetchWithCache<T>(inputKey, doFetch, opts);
|
|
257
|
+
},
|
|
258
|
+
inflightBackstopMs,
|
|
259
|
+
`fetchCache ${cacheKey}`,
|
|
260
|
+
);
|
|
242
261
|
}
|
|
243
262
|
|
|
244
263
|
// Cold miss: run the loader. Wrap with a timeout so `.finally()` always
|
|
@@ -256,8 +275,13 @@ export function createFetchCache(config: FetchCacheConfig): FetchCache {
|
|
|
256
275
|
}
|
|
257
276
|
return fresh;
|
|
258
277
|
})
|
|
259
|
-
.finally(() =>
|
|
278
|
+
.finally(() => {
|
|
279
|
+
if (inflight.get(cacheKey) === promise) inflight.delete(cacheKey);
|
|
280
|
+
});
|
|
260
281
|
|
|
282
|
+
// Keep the shared fetch alive past its owner request (client disconnect)
|
|
283
|
+
// so joiners still get the answer.
|
|
284
|
+
cacheBackground(promise);
|
|
261
285
|
inflight.set(cacheKey, promise);
|
|
262
286
|
return promise.then((e) => e.body as T | null);
|
|
263
287
|
}
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { describe, expect, it, vi } from "vitest";
|
|
2
|
-
import { DEFAULT_INFLIGHT_TIMEOUT_MS, withInflightTimeout } from "./inflightTimeout";
|
|
2
|
+
import { DEFAULT_INFLIGHT_TIMEOUT_MS, joinInflight, withInflightTimeout } from "./inflightTimeout";
|
|
3
3
|
|
|
4
4
|
describe("withInflightTimeout", () => {
|
|
5
5
|
it("returns the underlying value when work settles in time", async () => {
|
|
@@ -33,3 +33,29 @@ describe("withInflightTimeout", () => {
|
|
|
33
33
|
expect(DEFAULT_INFLIGHT_TIMEOUT_MS).toBeLessThanOrEqual(60_000);
|
|
34
34
|
});
|
|
35
35
|
});
|
|
36
|
+
|
|
37
|
+
describe("joinInflight — stall signal", () => {
|
|
38
|
+
it("logs one `[inflight] stall` with the label when the joiner gives up", async () => {
|
|
39
|
+
vi.useFakeTimers();
|
|
40
|
+
const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
|
|
41
|
+
try {
|
|
42
|
+
const joined = joinInflight(
|
|
43
|
+
new Promise<string>(() => {}),
|
|
44
|
+
async () => "rerun",
|
|
45
|
+
50,
|
|
46
|
+
"layoutSection k",
|
|
47
|
+
);
|
|
48
|
+
await vi.advanceTimersByTimeAsync(50);
|
|
49
|
+
expect(await joined).toBe("rerun");
|
|
50
|
+
expect(warn).toHaveBeenCalledTimes(1);
|
|
51
|
+
expect(warn.mock.calls[0][0]).toBe("[inflight] stall");
|
|
52
|
+
expect(JSON.parse(warn.mock.calls[0][1] as string)).toEqual({
|
|
53
|
+
label: "layoutSection k",
|
|
54
|
+
waitedMs: 50,
|
|
55
|
+
});
|
|
56
|
+
} finally {
|
|
57
|
+
warn.mockRestore();
|
|
58
|
+
vi.useRealTimers();
|
|
59
|
+
}
|
|
60
|
+
});
|
|
61
|
+
});
|
|
@@ -40,11 +40,7 @@ export function withInflightTimeout<T>(
|
|
|
40
40
|
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
41
41
|
const timeout = new Promise<never>((_, reject) => {
|
|
42
42
|
timer = setTimeout(() => {
|
|
43
|
-
reject(
|
|
44
|
-
new Error(
|
|
45
|
-
`[blocks] inflight cache entry "${label}" timed out after ${ms}ms`,
|
|
46
|
-
),
|
|
47
|
-
);
|
|
43
|
+
reject(new Error(`[blocks] inflight cache entry "${label}" timed out after ${ms}ms`));
|
|
48
44
|
}, ms);
|
|
49
45
|
});
|
|
50
46
|
return Promise.race([work, timeout]).finally(() => {
|
|
@@ -72,9 +68,17 @@ export function joinInflight<T>(
|
|
|
72
68
|
shared: Promise<T>,
|
|
73
69
|
onStall: () => Promise<T>,
|
|
74
70
|
ms: number = DEFAULT_INFLIGHT_TIMEOUT_MS,
|
|
71
|
+
label?: string,
|
|
75
72
|
): Promise<T> {
|
|
76
73
|
return new Promise<T>((resolve, reject) => {
|
|
77
74
|
const timer = setTimeout(() => {
|
|
75
|
+
// Observable signal: a joiner gave up on a shared flight. Steady volume
|
|
76
|
+
// means owners are being cancelled (client disconnects) or are slower
|
|
77
|
+
// than `ms`; a burst on one label is a poisoned key. Grep "[inflight] stall".
|
|
78
|
+
console.warn(
|
|
79
|
+
"[inflight] stall",
|
|
80
|
+
JSON.stringify({ label: label?.slice(0, 200) ?? null, waitedMs: ms }),
|
|
81
|
+
);
|
|
78
82
|
// `onStall` may throw synchronously (a non-async loader wrapper); route it
|
|
79
83
|
// into the Promise chain so the joiner rejects instead of hanging.
|
|
80
84
|
Promise.resolve().then(onStall).then(resolve, reject);
|