@cloudflare/workers-response-store 0.0.0 → 0.1.0-beta.1

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.
@@ -0,0 +1,727 @@
1
+ import { deriveCachePolicy, edgeCacheControl, representationAge } from "./cache-policy.js";
2
+ import { IsolateNegativeCache } from "./isolate-negative-cache.js";
3
+ import { WorkerEntrypoint } from "cloudflare:workers";
4
+ //#region src/binding.ts
5
+ var R2PublicationError = class extends Error {
6
+ constructor(cause) {
7
+ super("R2 response publication failed", { cause });
8
+ }
9
+ };
10
+ function getWorkersResponseStore(ctx, props = {}) {
11
+ const binding = Reflect.get(ctx.exports, "ResponseStoreBinding");
12
+ if (typeof binding !== "function") throw new Error("The ResponseStoreBinding entrypoint is not exported");
13
+ return binding({ props });
14
+ }
15
+ var ResponseStoreService = class extends WorkerEntrypoint {
16
+ getStore(invocation) {
17
+ return getWorkersResponseStore(this.ctx, {
18
+ ...this.ctx.props,
19
+ ...invocation
20
+ });
21
+ }
22
+ read(request, invocation) {
23
+ return this.getStore(invocation).fetch(request);
24
+ }
25
+ getTagExpiration(tags, invocation) {
26
+ return this.getStore(invocation).getTagExpiration(tags);
27
+ }
28
+ put(request, response, options, invocation) {
29
+ return this.getStore(invocation).put(request, response, options);
30
+ }
31
+ refresh(options, invocation) {
32
+ return this.getStore(invocation).refresh(options);
33
+ }
34
+ purge(options, invocation) {
35
+ return this.getStore(invocation).purge(options);
36
+ }
37
+ };
38
+ const MISS_HEADERS = {
39
+ "Cache-Control": "no-store",
40
+ "Content-Type": "text/plain; charset=utf-8",
41
+ "X-Workers-Response-Store": "MISS"
42
+ };
43
+ const BACKGROUND_REVALIDATION_LEASE_MS = 3e4;
44
+ const CACHE_PURGE_BATCH_SIZE = 100;
45
+ const PURGE_TOMBSTONE_BATCH_SIZE = 400;
46
+ const ISOLATE_MISS_CACHE_CAPACITY = 1024;
47
+ const ISOLATE_MISS_CACHE_TTL_MS = 1e3;
48
+ const MAX_R2_CAS_ATTEMPTS = 3;
49
+ const MAX_CACHE_TAG_HEADER_BYTES = 16384;
50
+ const R2_CUSTOM_METADATA_SAFE_BYTES = 7168;
51
+ const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
52
+ 204,
53
+ 205,
54
+ 304
55
+ ]);
56
+ const AGE_BASIS_HEADER = "X-Workers-Response-Store-Age-Basis";
57
+ const STORAGE_LAYOUT_VERSION = "r2-v1";
58
+ const pendingPuts = /* @__PURE__ */ new Map();
59
+ const pendingR2Reads = /* @__PURE__ */ new Map();
60
+ const entryReads = new IsolateNegativeCache(ISOLATE_MISS_CACHE_CAPACITY, ISOLATE_MISS_CACHE_TTL_MS);
61
+ function validateResponseStoreShards(shards) {
62
+ if (shards !== void 0 && (!Number.isSafeInteger(shards) || shards <= 1)) throw new TypeError("Workers Response Store shards must be an integer greater than 1");
63
+ return shards;
64
+ }
65
+ function* batches(values, size) {
66
+ for (let offset = 0; offset < values.length; offset += size) yield values.slice(offset, offset + size);
67
+ }
68
+ function metadataInteger(value) {
69
+ if (!value || !/^\d+$/.test(value)) return;
70
+ const parsed = Number(value);
71
+ return Number.isSafeInteger(parsed) ? parsed : void 0;
72
+ }
73
+ function metadataJson(value) {
74
+ if (value === void 0) return void 0;
75
+ try {
76
+ return JSON.parse(value);
77
+ } catch {
78
+ return;
79
+ }
80
+ }
81
+ function isHeaderEntries(value) {
82
+ return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && entry.length === 2 && entry.every((item) => typeof item === "string"));
83
+ }
84
+ function customMetadataSize(metadata) {
85
+ const encoder = new TextEncoder();
86
+ return Object.entries(metadata).reduce((size, [key, value]) => size + encoder.encode(key).byteLength + encoder.encode(value).byteLength, 0);
87
+ }
88
+ async function readBodyPrefix(body, prefixLength) {
89
+ const reader = body.getReader();
90
+ const chunks = [];
91
+ let length = 0;
92
+ try {
93
+ while (length < prefixLength) {
94
+ const { done, value } = await reader.read();
95
+ if (done) throw new Error("R2 response metadata prefix is incomplete");
96
+ chunks.push(value);
97
+ length += value.byteLength;
98
+ }
99
+ } catch (error) {
100
+ await reader.cancel(error).catch(() => {});
101
+ throw error;
102
+ }
103
+ const buffered = new Uint8Array(length);
104
+ let offset = 0;
105
+ for (const chunk of chunks) {
106
+ buffered.set(chunk, offset);
107
+ offset += chunk.byteLength;
108
+ }
109
+ const leftover = buffered.subarray(prefixLength);
110
+ return {
111
+ prefix: buffered.subarray(0, prefixLength),
112
+ remainder: new ReadableStream({
113
+ start(controller) {
114
+ if (leftover.byteLength) controller.enqueue(leftover);
115
+ },
116
+ async pull(controller) {
117
+ const { done, value } = await reader.read();
118
+ if (done) controller.close();
119
+ else controller.enqueue(value);
120
+ },
121
+ cancel(reason) {
122
+ return reader.cancel(reason);
123
+ }
124
+ })
125
+ };
126
+ }
127
+ function purgeTagForEntry(entry) {
128
+ return `runtime-cache-${entry.keyHash}`;
129
+ }
130
+ function cacheTagHeader(entry) {
131
+ const requiredTag = purgeTagForEntry(entry);
132
+ const tags = [requiredTag];
133
+ const seen = /* @__PURE__ */ new Set([requiredTag.toLowerCase()]);
134
+ let headerLength = requiredTag.length;
135
+ for (const tag of entry.cacheTags) {
136
+ const normalized = tag.toLowerCase();
137
+ if (!/^[!-~]+$/.test(tag) || tag.includes(",") || seen.has(normalized)) continue;
138
+ const addedLength = tag.length + 1;
139
+ if (headerLength + addedLength > MAX_CACHE_TAG_HEADER_BYTES) continue;
140
+ tags.push(tag);
141
+ seen.add(normalized);
142
+ headerLength += addedLength;
143
+ }
144
+ return tags.join(",");
145
+ }
146
+ function cacheTagsFromResponse(response) {
147
+ return [...new Set((response.headers.get("Cache-Tag") ?? "").split(",").map((tag) => tag.trim()).filter(Boolean))];
148
+ }
149
+ var ResponseStoreBinding = class extends WorkerEntrypoint {
150
+ shardCount = validateResponseStoreShards(this.ctx.props?.shards) ?? 1;
151
+ getVersionId() {
152
+ const versionId = this.ctx.props?.versionId ?? this.env.CF_VERSION_METADATA?.id;
153
+ if (!versionId) throw new Error("Workers Response Store requires a version_metadata binding");
154
+ return versionId;
155
+ }
156
+ getMetadataShard(index) {
157
+ const locationHint = this.ctx.props?.locationHint;
158
+ const shards = this.shardCount;
159
+ const layoutName = `${this.getVersionId()}:${STORAGE_LAYOUT_VERSION}`;
160
+ const name = shards === 1 ? layoutName : `${layoutName}:metadata-shard:${index}-of-${shards}`;
161
+ return this.env.CACHE_METADATA.getByName(name, locationHint ? { locationHint } : void 0);
162
+ }
163
+ getMetadata(keyHash) {
164
+ const shards = this.shardCount;
165
+ const index = shards === 1 ? 0 : Number.parseInt(keyHash.slice(0, 8), 16) % shards;
166
+ return this.getMetadataShard(index);
167
+ }
168
+ getMetadataShards() {
169
+ return Array.from({ length: this.shardCount }, (_, index) => this.getMetadataShard(index));
170
+ }
171
+ entryReadKey(keyHash) {
172
+ return `${this.getVersionId()}:${this.shardCount}:${keyHash}`;
173
+ }
174
+ invalidateEntryRead(keyHash) {
175
+ const key = this.entryReadKey(keyHash);
176
+ entryReads.delete(key);
177
+ pendingR2Reads.delete(key);
178
+ }
179
+ getTagMetadata(tags) {
180
+ const shards = this.shardCount;
181
+ if (shards === 1) return this.getMetadataShard(0);
182
+ let hash = 2166136261;
183
+ const normalized = [...new Set(tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))].sort().join("\0");
184
+ for (let index = 0; index < normalized.length; index++) hash = Math.imul(hash ^ normalized.charCodeAt(index), 16777619);
185
+ return this.getMetadataShard((hash >>> 0) % shards);
186
+ }
187
+ async deriveCacheKey(request) {
188
+ if (request.method !== "GET") throw new TypeError("Workers Response Store keys must be GET requests");
189
+ const url = new URL(request.url);
190
+ const cacheKey = `${url.pathname}${url.search}`;
191
+ const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(cacheKey));
192
+ return {
193
+ cacheKey,
194
+ keyHash: [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")
195
+ };
196
+ }
197
+ async purgeEdgeCache(options) {
198
+ if (!this.ctx.cache) {
199
+ console.error(JSON.stringify({
200
+ message: "Workers Response Store cache purge is unavailable",
201
+ reason: "ctx.cache is absent"
202
+ }));
203
+ return false;
204
+ }
205
+ try {
206
+ const result = await this.ctx.cache.purge(options);
207
+ if (!result.success) throw new Error(result.errors.map(({ code, message }) => `${code}: ${message}`).join(", ") || "Workers Response Store cache purge was rejected");
208
+ return true;
209
+ } catch (error) {
210
+ console.error(JSON.stringify({
211
+ message: "Workers Response Store cache purge failed",
212
+ error: error instanceof Error ? error.message : String(error)
213
+ }));
214
+ throw error;
215
+ }
216
+ }
217
+ async purgeEdgeCacheByTags(tags) {
218
+ let accepted = true;
219
+ for (const batch of batches(tags, CACHE_PURGE_BATCH_SIZE)) if (!await this.purgeEdgeCache({ tags: batch })) accepted = false;
220
+ return accepted;
221
+ }
222
+ async purgeR2TombstoneEdges(entries) {
223
+ return await this.purgeEdgeCacheByTags(entries.map(purgeTagForEntry));
224
+ }
225
+ async purgePendingEdgeEntries(metadata, purgeByTag) {
226
+ let accepted = true;
227
+ for (;;) {
228
+ const entries = await metadata.listPendingEdgePurges(PURGE_TOMBSTONE_BATCH_SIZE);
229
+ if (!entries.length) return accepted;
230
+ if (purgeByTag && !await this.purgeEdgeCacheByTags(entries.map(purgeTagForEntry))) accepted = false;
231
+ await metadata.markTombstonesEdgePurged(entries);
232
+ }
233
+ }
234
+ objectKeyRoot() {
235
+ const shards = this.shardCount;
236
+ return [
237
+ "runtime-cache",
238
+ this.getVersionId(),
239
+ STORAGE_LAYOUT_VERSION,
240
+ ...shards === 1 ? [] : [`shards-${shards}`]
241
+ ].join("/");
242
+ }
243
+ objectKeyPrefix(keyHash) {
244
+ return `${this.objectKeyRoot()}/${keyHash}`;
245
+ }
246
+ r2ObjectKey(keyHash) {
247
+ return `${this.objectKeyPrefix(keyHash)}/active`;
248
+ }
249
+ entryFromR2Metadata(keyHash, cacheKey, object) {
250
+ const metadata = object?.customMetadata;
251
+ if (!metadata || metadata.tombstoned === "1") return null;
252
+ const latestRevision = metadataInteger(metadata.latestRevision);
253
+ const freshUntil = metadataInteger(metadata.freshUntil);
254
+ const swrUntil = metadataInteger(metadata.swrUntil);
255
+ const responseMetadataBytes = metadataInteger(metadata.responseMetadataBytes);
256
+ const responseHeaders = metadataJson(metadata.responseHeaders);
257
+ const hasResponseMetadataPrefix = responseMetadataBytes !== void 0 && responseMetadataBytes > 0 && responseMetadataBytes <= object.size;
258
+ if (latestRevision === void 0 || freshUntil === void 0 || swrUntil === void 0 || !hasResponseMetadataPrefix && (typeof metadata.statusText !== "string" || !isHeaderEntries(responseHeaders))) return null;
259
+ return {
260
+ keyHash,
261
+ cacheKey,
262
+ objectKey: this.r2ObjectKey(keyHash),
263
+ statusText: hasResponseMetadataPrefix ? "" : metadata.statusText,
264
+ responseHeaders: hasResponseMetadataPrefix ? [] : responseHeaders,
265
+ freshUntil,
266
+ swrUntil,
267
+ revalidator: null,
268
+ cacheTags: [],
269
+ activeRevision: latestRevision,
270
+ latestRevision
271
+ };
272
+ }
273
+ async readR2Metadata(cacheKey) {
274
+ const object = await this.env.CACHE_BODIES.get(this.r2ObjectKey(cacheKey.keyHash));
275
+ const entry = this.entryFromR2Metadata(cacheKey.keyHash, cacheKey.cacheKey, object);
276
+ if (!entry && object) await object.body.cancel();
277
+ return {
278
+ entry,
279
+ ...entry && object ? { object } : {}
280
+ };
281
+ }
282
+ async readR2MetadataCached(cacheKey) {
283
+ const readKey = this.entryReadKey(cacheKey.keyHash);
284
+ if (entryReads.has(readKey)) return { entry: null };
285
+ const existing = pendingR2Reads.get(readKey);
286
+ if (existing && !await existing) return { entry: null };
287
+ const read = this.readR2Metadata(cacheKey);
288
+ if (existing) return read;
289
+ let pending;
290
+ pending = read.then(({ entry }) => {
291
+ if (!entry && pendingR2Reads.get(readKey) === pending) entryReads.add(readKey);
292
+ return entry !== null;
293
+ }, () => true);
294
+ pendingR2Reads.set(readKey, pending);
295
+ try {
296
+ return await read;
297
+ } finally {
298
+ if (pendingR2Reads.get(readKey) === pending) pendingR2Reads.delete(readKey);
299
+ }
300
+ }
301
+ async writeR2Revision(objectKey, revision, body, customMetadata, expectedEtag) {
302
+ let etag = expectedEtag;
303
+ for (let attempt = 0; attempt < MAX_R2_CAS_ATTEMPTS; attempt++) {
304
+ if (etag === void 0) {
305
+ const current = await this.env.CACHE_BODIES.head(objectKey);
306
+ const currentRevision = metadataInteger(current?.customMetadata?.latestRevision);
307
+ if (currentRevision !== void 0 && currentRevision >= revision) return false;
308
+ etag = current?.etag ?? null;
309
+ }
310
+ if (await this.env.CACHE_BODIES.put(objectKey, body, {
311
+ onlyIf: etag === null ? { etagDoesNotMatch: "*" } : { etagMatches: etag },
312
+ customMetadata
313
+ })) return true;
314
+ etag = void 0;
315
+ }
316
+ const currentRevision = metadataInteger((await this.env.CACHE_BODIES.head(objectKey))?.customMetadata?.latestRevision);
317
+ if (currentRevision !== void 0 && currentRevision >= revision) return false;
318
+ throw new Error(`R2 revision ${revision} could not be published after concurrent writes`);
319
+ }
320
+ async writeR2Response(entry, body, status, createdAt, initialAge, expectedEtag) {
321
+ this.invalidateEntryRead(entry.keyHash);
322
+ try {
323
+ const responseHeaders = JSON.stringify(entry.responseHeaders);
324
+ let storedBody = body;
325
+ let customMetadata = {
326
+ status: String(status),
327
+ createdAt: String(createdAt),
328
+ initialAge: String(initialAge),
329
+ statusText: entry.statusText,
330
+ responseHeaders,
331
+ freshUntil: String(entry.freshUntil),
332
+ swrUntil: String(entry.swrUntil),
333
+ latestRevision: String(entry.activeRevision)
334
+ };
335
+ if (customMetadataSize(customMetadata) > R2_CUSTOM_METADATA_SAFE_BYTES) {
336
+ const responseMetadata = new TextEncoder().encode(JSON.stringify({
337
+ statusText: entry.statusText,
338
+ responseHeaders: entry.responseHeaders
339
+ }));
340
+ storedBody = new Blob([responseMetadata, body]);
341
+ customMetadata = {
342
+ status: String(status),
343
+ createdAt: String(createdAt),
344
+ initialAge: String(initialAge),
345
+ responseMetadataBytes: String(responseMetadata.byteLength),
346
+ freshUntil: String(entry.freshUntil),
347
+ swrUntil: String(entry.swrUntil),
348
+ latestRevision: String(entry.activeRevision)
349
+ };
350
+ }
351
+ return await this.writeR2Revision(this.r2ObjectKey(entry.keyHash), entry.activeRevision, storedBody, customMetadata, expectedEtag);
352
+ } finally {
353
+ this.invalidateEntryRead(entry.keyHash);
354
+ }
355
+ }
356
+ readableEntry(entry) {
357
+ return entry ? {
358
+ ...entry,
359
+ cacheTags: [],
360
+ objectKey: this.r2ObjectKey(entry.keyHash)
361
+ } : entry;
362
+ }
363
+ async reserveWrite(metadata, cacheKey, cacheTags) {
364
+ const reservation = await metadata.reserveWrite(cacheKey.keyHash, cacheKey.cacheKey, this.objectKeyPrefix(cacheKey.keyHash), Date.now());
365
+ return {
366
+ ...cacheKey,
367
+ fenceTags: cacheTags,
368
+ ...reservation
369
+ };
370
+ }
371
+ logCleanupFailure(objectKey, error) {
372
+ console.error(JSON.stringify({
373
+ message: "Workers Response Store R2 cleanup failed",
374
+ objectKey,
375
+ error: error instanceof Error ? error.message : String(error)
376
+ }));
377
+ }
378
+ async releaseFailedWrite(metadata, write) {
379
+ await metadata.releaseWrite(write.keyHash, write.objectKey, write.claimId).catch((error) => this.logCleanupFailure(write.objectKey, error));
380
+ }
381
+ createStoredResponse(entry, body, status, createdAt, initialAge, now = Date.now()) {
382
+ const headers = new Headers(entry.responseHeaders);
383
+ headers.set(AGE_BASIS_HEADER, `${createdAt}:${initialAge}`);
384
+ headers.set("Age", String(representationAge(createdAt, initialAge, now)));
385
+ headers.set("Cloudflare-CDN-Cache-Control", edgeCacheControl(entry.freshUntil, entry.swrUntil, now));
386
+ headers.set("Cache-Tag", cacheTagHeader(entry));
387
+ headers.set("X-Workers-Response-Store", now < entry.freshUntil ? "BLOB-FRESH" : "BLOB-STALE");
388
+ headers.set("X-Workers-Response-Store-Revision", String(entry.activeRevision));
389
+ headers.set("X-Workers-Response-Store-Binding-Invocation", crypto.randomUUID());
390
+ return new Response(body, {
391
+ status,
392
+ statusText: entry.statusText,
393
+ headers
394
+ });
395
+ }
396
+ async readStoredResponse(entry, now = Date.now(), prefetchedObject) {
397
+ const object = prefetchedObject ?? await this.env.CACHE_BODIES.get(entry.objectKey);
398
+ if (!object) return null;
399
+ const status = metadataInteger(object.customMetadata?.status);
400
+ const createdAt = metadataInteger(object.customMetadata?.createdAt);
401
+ const initialAge = metadataInteger(object.customMetadata?.initialAge);
402
+ if (status === void 0 || status < 200 || status > 599 || createdAt === void 0 || initialAge === void 0) {
403
+ await object.body.cancel();
404
+ return null;
405
+ }
406
+ let storedEntry = entry;
407
+ let storedBody = object.body;
408
+ const responseMetadataBytes = metadataInteger(object.customMetadata?.responseMetadataBytes);
409
+ if (responseMetadataBytes !== void 0) try {
410
+ const { prefix, remainder } = await readBodyPrefix(storedBody, responseMetadataBytes);
411
+ const responseMetadata = metadataJson(new TextDecoder().decode(prefix));
412
+ if (typeof responseMetadata !== "object" || responseMetadata === null || !("statusText" in responseMetadata) || typeof responseMetadata.statusText !== "string" || !("responseHeaders" in responseMetadata) || !isHeaderEntries(responseMetadata.responseHeaders)) {
413
+ await remainder.cancel();
414
+ return null;
415
+ }
416
+ storedEntry = {
417
+ ...entry,
418
+ statusText: responseMetadata.statusText,
419
+ responseHeaders: responseMetadata.responseHeaders
420
+ };
421
+ storedBody = remainder;
422
+ } catch {
423
+ await storedBody.cancel().catch(() => {});
424
+ return null;
425
+ }
426
+ const body = NULL_BODY_STATUSES.has(status) ? null : storedBody;
427
+ if (!body) await storedBody.cancel();
428
+ return this.createStoredResponse(storedEntry, body, status, createdAt, initialAge, now);
429
+ }
430
+ async storeResponse(metadata, request, response, revalidator, reservation, cacheTags = cacheTagsFromResponse(response), expectedR2Etag) {
431
+ const cacheKey = reservation ?? await this.deriveCacheKey(request);
432
+ const write = reservation ?? await this.reserveWrite(metadata, cacheKey, cacheTags);
433
+ const { keyHash, objectKey: reservationObjectKey, revision } = write;
434
+ let publication;
435
+ let body;
436
+ let policy;
437
+ try {
438
+ const now = Date.now();
439
+ policy = deriveCachePolicy(response.headers, now);
440
+ const responseHeaders = [...response.headers].filter(([name]) => {
441
+ const lower = name.toLowerCase();
442
+ return lower !== "age" && lower !== "cache-tag" && lower !== "cf-cache-status" && lower !== "content-length";
443
+ });
444
+ const candidate = {
445
+ fenceTags: [.../* @__PURE__ */ new Set([...write.fenceTags, ...cacheTags])],
446
+ objectKey: this.r2ObjectKey(keyHash),
447
+ statusText: response.statusText,
448
+ responseHeaders,
449
+ freshUntil: policy.freshUntil,
450
+ swrUntil: policy.swrUntil,
451
+ revalidator: revalidator ?? null,
452
+ cacheTags
453
+ };
454
+ body = response.body ? await response.arrayBuffer() : /* @__PURE__ */ new ArrayBuffer(0);
455
+ publication = await metadata.publish(keyHash, revision, candidate, write.claimId, reservationObjectKey);
456
+ } catch (error) {
457
+ await this.releaseFailedWrite(metadata, write);
458
+ throw error;
459
+ }
460
+ if (!publication.published) return {
461
+ published: false,
462
+ entry: this.readableEntry(publication.entry)
463
+ };
464
+ let stored = false;
465
+ if (publication.entry) try {
466
+ stored = await this.writeR2Response(publication.entry, body, response.status, policy.createdAt, policy.initialAge, expectedR2Etag !== void 0 ? expectedR2Etag : write.r2ObjectAbsent ? null : void 0);
467
+ } catch (error) {
468
+ const reconciliation = await metadata.invalidatePublishedRevision(publication.entry.keyHash, publication.entry.activeRevision).catch((reconciliationError) => ({
469
+ failures: [reconciliationError instanceof Error ? reconciliationError.message : String(reconciliationError)],
470
+ pending: [],
471
+ purged: []
472
+ }));
473
+ const reconciliationFailures = reconciliation.failures.map((failure) => new Error(failure));
474
+ if (reconciliation.purged.length) try {
475
+ await this.purgeEdgeCacheByTags(reconciliation.purged.map(purgeTagForEntry));
476
+ await metadata.markTombstonesEdgePurged(reconciliation.purged);
477
+ } catch (reconciliationError) {
478
+ reconciliationFailures.push(reconciliationError instanceof Error ? reconciliationError : new Error(String(reconciliationError)));
479
+ }
480
+ if (reconciliationFailures.length) {
481
+ const failure = new AggregateError([error, ...reconciliationFailures], "R2 response publication and reconciliation failed");
482
+ if (reconciliation.pending.length) throw new R2PublicationError(failure);
483
+ throw failure;
484
+ }
485
+ if (reconciliation.pending.length) throw new R2PublicationError(error);
486
+ throw error;
487
+ }
488
+ const entry = this.readableEntry(publication.entry);
489
+ return {
490
+ published: true,
491
+ entry,
492
+ ...stored && entry ? { response: this.createStoredResponse(entry, NULL_BODY_STATUSES.has(response.status) ? null : body, response.status, policy.createdAt, policy.initialAge) } : {}
493
+ };
494
+ }
495
+ async regenerateEntry(metadata, entry, reason, reservation, expectedR2Etag) {
496
+ if (!entry.revalidator) throw new Error("Cache entry has no configured revalidator");
497
+ const cacheRequest = new Request(`https://runtime-cache.invalid${entry.cacheKey}`);
498
+ const writeReservation = reservation ?? await this.reserveWrite(metadata, {
499
+ cacheKey: entry.cacheKey,
500
+ keyHash: entry.keyHash
501
+ }, entry.cacheTags);
502
+ let response;
503
+ try {
504
+ const origin = this.ctx.props?.revalidator ?? Reflect.get(this.ctx.exports, "ResponseStoreRevalidator");
505
+ if (typeof origin?.regenerate !== "function") throw new Error("The ResponseStoreRevalidator entrypoint is unavailable");
506
+ response = await origin.regenerate({
507
+ request: cacheRequest,
508
+ id: entry.revalidator.id,
509
+ args: entry.revalidator.args,
510
+ reason
511
+ });
512
+ } catch (error) {
513
+ await this.releaseFailedWrite(metadata, writeReservation);
514
+ throw error;
515
+ }
516
+ return this.storeResponse(metadata, cacheRequest, response, entry.revalidator, writeReservation, void 0, expectedR2Etag);
517
+ }
518
+ async revalidateEntryInBackground(metadata, entry, expectedR2Etag) {
519
+ const claim = await metadata.claimRevalidation(entry.keyHash, entry.activeRevision, entry.cacheKey, this.objectKeyPrefix(entry.keyHash), Date.now(), BACKGROUND_REVALIDATION_LEASE_MS);
520
+ if (!claim) return;
521
+ try {
522
+ await this.regenerateEntry(metadata, claim.entry, "swr", {
523
+ cacheKey: claim.entry.cacheKey,
524
+ claimId: claim.claimId,
525
+ fenceTags: claim.entry.cacheTags,
526
+ keyHash: claim.entry.keyHash,
527
+ objectKey: claim.objectKey,
528
+ revision: claim.revision
529
+ }, expectedR2Etag);
530
+ } catch (error) {
531
+ console.error(JSON.stringify({
532
+ message: "Workers Response Store SWR regeneration failed",
533
+ cacheKey: entry.cacheKey,
534
+ error: error instanceof Error ? error.message : String(error)
535
+ }));
536
+ }
537
+ }
538
+ async fetch(request) {
539
+ const cacheKey = await this.deriveCacheKey(request);
540
+ const { keyHash } = cacheKey;
541
+ const r2Read = await this.readR2MetadataCached(cacheKey);
542
+ const entry = r2Read.entry;
543
+ const expectedR2Etag = r2Read.object?.etag;
544
+ if (!entry) return new Response("Workers Response Store miss", {
545
+ status: 404,
546
+ headers: MISS_HEADERS
547
+ });
548
+ const now = Date.now();
549
+ if (now < entry.swrUntil) {
550
+ const stored = await this.readStoredResponse(entry, now, r2Read?.object);
551
+ if (stored) {
552
+ if (now < entry.freshUntil) return stored;
553
+ this.ctx.waitUntil(Promise.resolve().then(async () => {
554
+ const metadata = this.getMetadata(keyHash);
555
+ await this.revalidateEntryInBackground(metadata, entry, expectedR2Etag);
556
+ }));
557
+ return stored;
558
+ }
559
+ }
560
+ await r2Read?.object?.body.cancel().catch(() => {});
561
+ const metadata = this.getMetadata(keyHash);
562
+ const regeneration = await metadata.reserveRegeneration(keyHash, cacheKey.cacheKey, this.objectKeyPrefix(keyHash), now);
563
+ if (!regeneration) return new Response("Workers Response Store miss", {
564
+ status: 404,
565
+ headers: MISS_HEADERS
566
+ });
567
+ const regenerated = await this.regenerateEntry(metadata, regeneration.entry, now >= entry.swrUntil ? "expired" : "missing", regeneration.reservation ? {
568
+ ...cacheKey,
569
+ fenceTags: regeneration.entry.cacheTags,
570
+ ...regeneration.reservation
571
+ } : void 0, expectedR2Etag);
572
+ if (!regenerated.entry) throw new Error("Regeneration was superseded and no active entry remains");
573
+ let response = regenerated.response;
574
+ if (!response) {
575
+ const winner = await this.readR2Metadata(cacheKey);
576
+ if (winner.entry) response = await this.readStoredResponse(winner.entry, Date.now(), winner.object) ?? void 0;
577
+ }
578
+ if (!response) throw new Error("The committed cache body is unavailable");
579
+ return response;
580
+ }
581
+ getTagExpiration(tags) {
582
+ return this.getTagMetadata(tags).getTagExpiration(tags);
583
+ }
584
+ async put(request, response, options = {}) {
585
+ const cacheKey = await this.deriveCacheKey(request);
586
+ const { keyHash } = cacheKey;
587
+ const metadata = this.getMetadata(keyHash);
588
+ const cacheTags = cacheTagsFromResponse(response);
589
+ const pendingPutKey = `${this.getVersionId()}:${this.shardCount}:${keyHash}:${Boolean(options.purgeExisting)}`;
590
+ let reservation;
591
+ if (options.coalesce) for (;;) {
592
+ const pending = pendingPuts.get(pendingPutKey);
593
+ if (!pending) break;
594
+ reservation ??= await this.reserveWrite(metadata, cacheKey, cacheTags);
595
+ let result;
596
+ try {
597
+ result = await pending;
598
+ } catch (error) {
599
+ if (error instanceof R2PublicationError && reservation) {
600
+ const replacement = await metadata.replaceFailedWrite(keyHash, cacheKey.cacheKey, this.objectKeyPrefix(keyHash), reservation.objectKey, cacheTags, Date.now());
601
+ reservation = replacement ? {
602
+ ...cacheKey,
603
+ fenceTags: cacheTags,
604
+ ...replacement
605
+ } : void 0;
606
+ }
607
+ if (pendingPuts.get(pendingPutKey) === pending) pendingPuts.delete(pendingPutKey);
608
+ if (error instanceof R2PublicationError && !reservation) {
609
+ response.body?.cancel().catch(() => {});
610
+ return {
611
+ backingStoreUpdated: false,
612
+ edgePurgeAccepted: false
613
+ };
614
+ }
615
+ continue;
616
+ }
617
+ if (result?.published && result.entry) {
618
+ const objectKey = reservation.objectKey;
619
+ await metadata.finishPendingObjects([objectKey]).catch((error) => this.logCleanupFailure(objectKey, error));
620
+ response.body?.cancel().catch(() => {});
621
+ return {
622
+ backingStoreUpdated: true,
623
+ edgePurgeAccepted: options.purgeExisting ? await this.purgeEdgeCacheByTags([purgeTagForEntry(result.entry)]) : true
624
+ };
625
+ }
626
+ if (pendingPuts.get(pendingPutKey) === pending) pendingPuts.delete(pendingPutKey);
627
+ }
628
+ const write = (async () => {
629
+ reservation ??= await this.reserveWrite(metadata, cacheKey, cacheTags);
630
+ return this.storeResponse(metadata, request, response, options.revalidator, reservation, cacheTags);
631
+ })();
632
+ if (options.coalesce) pendingPuts.set(pendingPutKey, write);
633
+ try {
634
+ const result = await write;
635
+ if (!result.published || !result.entry) return {
636
+ backingStoreUpdated: false,
637
+ edgePurgeAccepted: false
638
+ };
639
+ return {
640
+ backingStoreUpdated: true,
641
+ edgePurgeAccepted: options.purgeExisting ? await this.purgeEdgeCacheByTags([purgeTagForEntry(result.entry)]) : true
642
+ };
643
+ } finally {
644
+ if (options.coalesce && pendingPuts.get(pendingPutKey) === write) pendingPuts.delete(pendingPutKey);
645
+ }
646
+ }
647
+ async refresh(options) {
648
+ if (!options.tags?.length && !options.pathPrefixes?.length) throw new TypeError("refresh() requires tags or pathPrefixes");
649
+ const reserved = await Promise.allSettled(this.getMetadataShards().map(async (metadata) => ({
650
+ candidates: await metadata.reserveRefresh(options, this.objectKeyRoot(), Date.now()),
651
+ metadata
652
+ })));
653
+ const failures = reserved.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
654
+ const candidates = reserved.flatMap((result) => result.status === "fulfilled" ? [result.value] : []).flatMap(({ candidates, metadata }) => candidates.map((candidate) => ({
655
+ ...candidate,
656
+ metadata
657
+ })));
658
+ if (candidates.length === 0) {
659
+ if (failures.length) throw new AggregateError(failures, "One or more cache entries failed to refresh");
660
+ return {
661
+ backingStoreUpdated: false,
662
+ edgePurgeAccepted: false
663
+ };
664
+ }
665
+ const settled = await Promise.allSettled(candidates.map(async ({ entry, metadata, reservation }) => {
666
+ const result = await this.regenerateEntry(metadata, entry, "manual", reservation ? {
667
+ cacheKey: entry.cacheKey,
668
+ fenceTags: entry.cacheTags,
669
+ keyHash: entry.keyHash,
670
+ ...reservation
671
+ } : void 0);
672
+ return result.published ? result.entry : null;
673
+ }));
674
+ const refreshed = [];
675
+ for (const result of settled) if (result.status === "rejected") failures.push(result.reason);
676
+ else if (result.value) refreshed.push(result.value);
677
+ const edgePurgeAccepted = refreshed.length ? await this.purgeEdgeCacheByTags(refreshed.map((entry) => purgeTagForEntry(entry))) : false;
678
+ if (failures.length) throw new AggregateError(failures, "One or more cache entries failed to refresh");
679
+ return {
680
+ backingStoreUpdated: refreshed.length === candidates.length,
681
+ edgePurgeAccepted
682
+ };
683
+ }
684
+ async purge(options) {
685
+ if (!options.purgeEverything && !options.tags?.length && !options.pathPrefixes?.length) throw new TypeError("purge() requires tags, pathPrefixes, or purgeEverything");
686
+ const invalidatedAt = Date.now();
687
+ const settled = await Promise.allSettled(this.getMetadataShards().map((metadata) => metadata.purgeMatching(options, invalidatedAt)));
688
+ const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
689
+ const reservations = settled.flatMap((result, index) => result.status === "fulfilled" ? [{
690
+ metadata: this.getMetadataShard(index),
691
+ reservation: result.value
692
+ }] : []);
693
+ for (const { metadata, reservation } of reservations) {
694
+ const batchCount = Math.ceil(reservation.pendingTombstones / PURGE_TOMBSTONE_BATCH_SIZE);
695
+ let cursor;
696
+ for (let batch = 0; batch < batchCount; batch++) try {
697
+ const drained = await metadata.drainPendingTombstones(PURGE_TOMBSTONE_BATCH_SIZE, void 0, cursor);
698
+ cursor = drained.cursor;
699
+ failures.push(...drained.failures.map((failure) => new Error(failure)));
700
+ } catch (error) {
701
+ failures.push(error);
702
+ }
703
+ }
704
+ let edgePurgeAccepted = true;
705
+ if (options.purgeEverything && failures.length === 0) try {
706
+ edgePurgeAccepted = await this.purgeEdgeCache({ purgeEverything: true });
707
+ const acknowledged = await Promise.allSettled(reservations.map(({ metadata }) => this.purgePendingEdgeEntries(metadata, true)));
708
+ for (const result of acknowledged) if (result.status === "rejected") failures.push(result.reason);
709
+ } catch (error) {
710
+ edgePurgeAccepted = false;
711
+ failures.push(error);
712
+ }
713
+ else {
714
+ if (options.purgeEverything) edgePurgeAccepted = false;
715
+ const acknowledged = await Promise.allSettled(reservations.map(({ metadata }) => this.purgePendingEdgeEntries(metadata, true)));
716
+ for (const result of acknowledged) if (result.status === "rejected") failures.push(result.reason);
717
+ else if (!result.value) edgePurgeAccepted = false;
718
+ }
719
+ if (failures.length) throw new AggregateError(failures, "One or more metadata shards failed to purge");
720
+ return {
721
+ backingStoreUpdated: reservations.some(({ reservation }) => reservation.backingStoreUpdated || reservation.pendingTombstones > 0),
722
+ edgePurgeAccepted
723
+ };
724
+ }
725
+ };
726
+ //#endregion
727
+ export { ResponseStoreBinding, ResponseStoreService, getWorkersResponseStore, validateResponseStoreShards };