@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,11 @@
1
+ //#region src/cache-policy.d.ts
2
+ export type CachePolicy = {
3
+ createdAt: number;
4
+ initialAge: number;
5
+ freshUntil: number;
6
+ swrUntil: number;
7
+ };
8
+ export declare function deriveCachePolicy(headers: Headers, now?: number): CachePolicy;
9
+ export declare function representationAge(createdAt: number, initialAge: number, now?: number): number;
10
+ export declare function edgeCacheControl(freshUntil: number, swrUntil: number, now?: number): string;
11
+ //#endregion
@@ -0,0 +1,37 @@
1
+ //#region src/cache-policy.ts
2
+ function parseSeconds(value) {
3
+ if (value === void 0) return;
4
+ const match = /^(?:"(\d+)"|(\d+))$/.exec(value);
5
+ if (!match) return;
6
+ const parsed = Number(match[1] ?? match[2]);
7
+ return Number.isSafeInteger(parsed) ? parsed : void 0;
8
+ }
9
+ function deriveCachePolicy(headers, now = Date.now()) {
10
+ const cacheControl = headers.get("Cloudflare-CDN-Cache-Control") ?? headers.get("CDN-Cache-Control") ?? headers.get("Cache-Control");
11
+ const directives = /* @__PURE__ */ new Map();
12
+ for (const part of cacheControl?.split(",") ?? []) {
13
+ const [rawName, ...rawValue] = part.trim().split("=");
14
+ if (!rawName) continue;
15
+ directives.set(rawName.toLowerCase(), rawValue.length ? rawValue.join("=").trim() : void 0);
16
+ }
17
+ const cacheStorageForbidden = directives.has("no-store") || directives.has("private");
18
+ const staleServingForbidden = directives.has("s-maxage") || directives.has("must-revalidate") || directives.has("proxy-revalidate");
19
+ const maxAge = cacheStorageForbidden || directives.has("no-cache") ? 0 : parseSeconds(directives.get("s-maxage")) ?? parseSeconds(directives.get("max-age")) ?? 0;
20
+ const initialAge = parseSeconds(headers.get("Age") ?? void 0) ?? 0;
21
+ const freshUntil = now + Math.max(0, maxAge - initialAge) * 1e3;
22
+ return {
23
+ createdAt: now,
24
+ initialAge,
25
+ freshUntil,
26
+ swrUntil: freshUntil + (cacheStorageForbidden || staleServingForbidden ? 0 : parseSeconds(directives.get("stale-while-revalidate")) ?? 0) * 1e3
27
+ };
28
+ }
29
+ function representationAge(createdAt, initialAge, now = Date.now()) {
30
+ return initialAge + Math.max(0, Math.floor((now - createdAt) / 1e3));
31
+ }
32
+ function edgeCacheControl(freshUntil, swrUntil, now = Date.now()) {
33
+ if (now < freshUntil) return `max-age=${Math.max(0, Math.ceil((freshUntil - now) / 1e3))}, stale-while-revalidate=${Math.max(0, Math.ceil((swrUntil - freshUntil) / 1e3))}`;
34
+ return `max-age=0, stale-while-revalidate=${Math.max(0, Math.ceil((swrUntil - now) / 1e3))}`;
35
+ }
36
+ //#endregion
37
+ export { deriveCachePolicy, edgeCacheControl, representationAge };
@@ -0,0 +1,36 @@
1
+ import { ResponseStoreBinding, ResponseStoreMutationResult, ResponseStorePurgeOptions, ResponseStorePutOptions, ResponseStoreRefreshOptions, RevalidationInput, RevalidationReason, RevalidationService, SerializableValue, WorkersResponseStore, WorkersResponseStoreEnv } from "./binding.js";
2
+ import { CacheMetadata } from "./metadata-do.js";
3
+ import { WorkerEntrypoint } from "cloudflare:workers";
4
+ //#region src/index.d.ts
5
+ export type ResponseStoreRevalidationContext<Env> = {
6
+ env: Env;
7
+ ctx: ExecutionContext;
8
+ };
9
+ export type ResponseStoreRevalidatorEntrypoint<Env = WorkersResponseStoreEnv> = new (ctx: ExecutionContext, env: Env) => WorkerEntrypoint<Env> & RevalidationService;
10
+ type WorkersResponseStoreDefinition<Env extends WorkersResponseStoreEnv = WorkersResponseStoreEnv> = WorkersResponseStore & {
11
+ entrypoints: {
12
+ CacheMetadata: typeof CacheMetadata;
13
+ ResponseStoreRevalidator: ResponseStoreRevalidatorEntrypoint<Env>;
14
+ ResponseStoreBinding: typeof ResponseStoreBinding;
15
+ };
16
+ };
17
+ type WorkersResponseStoreClientDefinition<Env> = WorkersResponseStore & {
18
+ entrypoints: {
19
+ ResponseStoreRevalidator: ResponseStoreRevalidatorEntrypoint<Env>;
20
+ ResponseStoreClient: new (ctx: ExecutionContext, env: Env) => WorkerEntrypoint<Env> & WorkersResponseStore;
21
+ };
22
+ };
23
+ export type ResponseStoreClientEntrypoint<Env = WorkersResponseStoreClientEnv> = new (ctx: ExecutionContext, env: Env) => WorkerEntrypoint<Env> & WorkersResponseStore;
24
+ export type WorkersResponseStoreOptions<Env> = {
25
+ /** Split version-scoped metadata across this many Durable Objects. */
26
+ shards?: number;
27
+ regenerate(input: RevalidationInput, context: ResponseStoreRevalidationContext<Env>): Response | Promise<Response>;
28
+ };
29
+ export declare function createWorkersResponseStore<Env extends WorkersResponseStoreEnv = WorkersResponseStoreEnv>(options: WorkersResponseStoreOptions<Env>): WorkersResponseStoreDefinition<Env>;
30
+ export type WorkersResponseStoreClientEnv = {
31
+ RESPONSE_STORE: Service;
32
+ CF_VERSION_METADATA: WorkerVersionMetadata;
33
+ };
34
+ export declare function createWorkersResponseStoreClient<Env extends WorkersResponseStoreClientEnv = WorkersResponseStoreClientEnv>(options: WorkersResponseStoreOptions<Env>): WorkersResponseStoreClientDefinition<Env>;
35
+ //#endregion
36
+ export type { ResponseStoreMutationResult, ResponseStorePurgeOptions, ResponseStorePutOptions, ResponseStoreRefreshOptions, RevalidationInput, RevalidationReason, SerializableValue, WorkersResponseStore, WorkersResponseStoreEnv };
package/dist/index.js ADDED
@@ -0,0 +1,85 @@
1
+ import { ResponseStoreBinding, getWorkersResponseStore, validateResponseStoreShards } from "./binding.js";
2
+ import { CacheMetadata } from "./metadata-do.js";
3
+ import { WorkerEntrypoint, exports } from "cloudflare:workers";
4
+ //#region src/index.ts
5
+ function createRevalidatorEntrypoint(options) {
6
+ return class ResponseStoreRevalidator extends WorkerEntrypoint {
7
+ async regenerate(input) {
8
+ return options.regenerate(input, {
9
+ env: this.env,
10
+ ctx: this.ctx
11
+ });
12
+ }
13
+ };
14
+ }
15
+ function createStoreFacade(getStore) {
16
+ return {
17
+ fetch: (request) => getStore().fetch(request),
18
+ getTagExpiration: (tags) => getStore().getTagExpiration(tags),
19
+ put: (request, response, options) => getStore().put(request, response, options),
20
+ refresh: (options) => getStore().refresh(options),
21
+ purge: (options) => getStore().purge(options)
22
+ };
23
+ }
24
+ function createWorkersResponseStore(options) {
25
+ const shards = validateResponseStoreShards(options.shards);
26
+ const ResponseStoreRevalidator = createRevalidatorEntrypoint(options);
27
+ const getStore = () => getWorkersResponseStore({ exports }, { shards });
28
+ return {
29
+ entrypoints: {
30
+ CacheMetadata,
31
+ ResponseStoreRevalidator,
32
+ ResponseStoreBinding
33
+ },
34
+ ...createStoreFacade(getStore)
35
+ };
36
+ }
37
+ function createWorkersResponseStoreClient(options) {
38
+ const shards = validateResponseStoreShards(options.shards);
39
+ const ResponseStoreRevalidator = createRevalidatorEntrypoint(options);
40
+ class ResponseStoreClient extends WorkerEntrypoint {
41
+ get service() {
42
+ return this.env.RESPONSE_STORE;
43
+ }
44
+ getInvocation() {
45
+ const factory = Reflect.get(this.ctx.exports, "ResponseStoreRevalidator");
46
+ if (typeof factory !== "function") throw new Error("The ResponseStoreRevalidator entrypoint is not exported");
47
+ const versionId = this.env.CF_VERSION_METADATA.id;
48
+ if (!versionId) throw new Error("Workers Response Store requires the user Worker version ID");
49
+ return {
50
+ versionId,
51
+ revalidator: factory({ props: {} }),
52
+ ...shards === void 0 ? {} : { shards }
53
+ };
54
+ }
55
+ fetch(request) {
56
+ return this.service.read(request, this.getInvocation());
57
+ }
58
+ getTagExpiration(tags) {
59
+ return this.service.getTagExpiration(tags, this.getInvocation());
60
+ }
61
+ put(request, response, putOptions = {}) {
62
+ return this.service.put(request, response, putOptions, this.getInvocation());
63
+ }
64
+ refresh(refreshOptions) {
65
+ return this.service.refresh(refreshOptions, this.getInvocation());
66
+ }
67
+ purge(purgeOptions) {
68
+ return this.service.purge(purgeOptions, this.getInvocation());
69
+ }
70
+ }
71
+ const getClient = () => {
72
+ const factory = Reflect.get(exports, "ResponseStoreClient");
73
+ if (typeof factory !== "function") throw new Error("The ResponseStoreClient entrypoint is not exported");
74
+ return factory({ props: {} });
75
+ };
76
+ return {
77
+ entrypoints: {
78
+ ResponseStoreRevalidator,
79
+ ResponseStoreClient
80
+ },
81
+ ...createStoreFacade(getClient)
82
+ };
83
+ }
84
+ //#endregion
85
+ export { createWorkersResponseStore, createWorkersResponseStoreClient };
@@ -0,0 +1,11 @@
1
+ //#region src/isolate-negative-cache.d.ts
2
+ export declare class IsolateNegativeCache<K> {
3
+ private readonly capacity;
4
+ private readonly ttlMs;
5
+ private readonly misses;
6
+ constructor(capacity: number, ttlMs: number);
7
+ has(key: K): boolean;
8
+ add(key: K): void;
9
+ delete(key: K): void;
10
+ }
11
+ //#endregion
@@ -0,0 +1,34 @@
1
+ //#region src/isolate-negative-cache.ts
2
+ var IsolateNegativeCache = class {
3
+ capacity;
4
+ ttlMs;
5
+ misses = /* @__PURE__ */ new Map();
6
+ constructor(capacity, ttlMs) {
7
+ this.capacity = capacity;
8
+ this.ttlMs = ttlMs;
9
+ }
10
+ has(key) {
11
+ const expiresAt = this.misses.get(key);
12
+ if (expiresAt === void 0) return false;
13
+ if (expiresAt <= Date.now()) {
14
+ this.misses.delete(key);
15
+ return false;
16
+ }
17
+ this.misses.delete(key);
18
+ this.misses.set(key, expiresAt);
19
+ return true;
20
+ }
21
+ add(key) {
22
+ this.misses.delete(key);
23
+ this.misses.set(key, Date.now() + this.ttlMs);
24
+ if (this.misses.size > this.capacity) {
25
+ const oldest = this.misses.keys().next();
26
+ if (!oldest.done) this.misses.delete(oldest.value);
27
+ }
28
+ }
29
+ delete(key) {
30
+ this.misses.delete(key);
31
+ }
32
+ };
33
+ //#endregion
34
+ export { IsolateNegativeCache };
@@ -0,0 +1,98 @@
1
+ import { CandidateMetadata, PurgedEntry, ResponseStorePurgeOptions, ResponseStoreRefreshOptions, StoredEntry } from "./binding.js";
2
+ import { DurableObject } from "cloudflare:workers";
3
+ //#region src/metadata-do.d.ts
4
+ type RevalidationClaim = {
5
+ claimId: string;
6
+ entry: StoredEntry;
7
+ objectKey: string;
8
+ revision: number;
9
+ };
10
+ type PublicationResult = {
11
+ entry: StoredEntry | null;
12
+ published: boolean;
13
+ };
14
+ type WriteReservation = {
15
+ objectKey: string;
16
+ r2ObjectAbsent: boolean;
17
+ revision: number;
18
+ };
19
+ type RefreshCandidate = {
20
+ entry: StoredEntry;
21
+ reservation?: Pick<WriteReservation, "objectKey" | "revision">;
22
+ };
23
+ type RegenerationReservation = {
24
+ entry: StoredEntry;
25
+ reservation?: WriteReservation;
26
+ };
27
+ type PurgeReservation = {
28
+ backingStoreUpdated: boolean;
29
+ pendingTombstones: number;
30
+ };
31
+ type TombstoneDrainResult = {
32
+ cursor?: string;
33
+ failures: string[];
34
+ pending: PurgedEntry[];
35
+ purged: PurgedEntry[];
36
+ };
37
+ export type CacheMetadataStub = DurableObjectStub & {
38
+ reserveWrite(keyHash: string, cacheKey: string, objectKeyPrefix: string, createdAt: number): Promise<WriteReservation>;
39
+ replaceFailedWrite(keyHash: string, cacheKey: string, objectKeyPrefix: string, failedObjectKey: string, fenceTags: string[], createdAt: number): Promise<WriteReservation | null>;
40
+ reserveRegeneration(keyHash: string, cacheKey: string, objectKeyPrefix: string, createdAt: number): Promise<RegenerationReservation | null>;
41
+ claimRevalidation(keyHash: string, activeRevision: number, cacheKey: string, objectKeyPrefix: string, now: number, leaseMs: number): Promise<RevalidationClaim | null>;
42
+ trackPendingObject(objectKey: string, createdAt: number): Promise<void>;
43
+ trackPendingObjects(objectKeys: string[], createdAt: number): Promise<void>;
44
+ releaseWrite(keyHash: string, objectKey: string, claimId?: string): Promise<void>;
45
+ finishPendingObjects(objectKeys: string[]): Promise<void>;
46
+ listExpiredPendingObjects(cutoff: number, limit: number): Promise<string[]>;
47
+ sweepExpiredPendingObjects(cutoff?: number): Promise<number>;
48
+ publish(keyHash: string, revision: number, metadata: CandidateMetadata, claimId?: string, reservationObjectKey?: string): Promise<PublicationResult>;
49
+ invalidatePublishedRevision(keyHash: string, revision: number): Promise<TombstoneDrainResult>;
50
+ getEntry(keyHash: string): Promise<StoredEntry | null>;
51
+ getTagExpiration(tags: string[]): Promise<number>;
52
+ reserveRefresh(options: ResponseStoreRefreshOptions, objectKeyRoot: string, createdAt: number): Promise<RefreshCandidate[]>;
53
+ purgeMatching(options: ResponseStorePurgeOptions, invalidatedAt?: number): Promise<PurgeReservation>;
54
+ drainPendingTombstones(limit: number, keyHash?: string, afterKeyHash?: string): Promise<TombstoneDrainResult>;
55
+ retryPendingTombstones(): Promise<boolean>;
56
+ listPendingEdgePurges(limit: number): Promise<PurgedEntry[]>;
57
+ markTombstonesEdgePurged(entries: PurgedEntry[]): Promise<void>;
58
+ inspect(): Promise<StoredEntry[]>;
59
+ };
60
+ type CacheMetadataEnv = {
61
+ CACHE_BODIES: R2Bucket;
62
+ };
63
+ export declare class CacheMetadata extends DurableObject<CacheMetadataEnv> {
64
+ private cleanupAlarmKnown;
65
+ constructor(ctx: DurableObjectState, env: CacheMetadataEnv);
66
+ private ensureCleanupAlarm;
67
+ private scheduleCleanupAlarm;
68
+ private logCleanupFailure;
69
+ private getR2TombstoneEdgePurger;
70
+ private findMatchingEntryRows;
71
+ trackPendingObjects(objectKeys: string[], createdAt: number): Promise<void>;
72
+ trackPendingObject(objectKey: string, createdAt: number): Promise<void>;
73
+ releaseWrite(keyHash: string, objectKey: string, claimId?: string): void;
74
+ finishPendingObjects(objectKeys: string[]): void;
75
+ listExpiredPendingObjects(cutoff: number, limit: number): string[];
76
+ sweepExpiredPendingObjects(cutoff?: number): Promise<number>;
77
+ alarm(): Promise<void>;
78
+ retryPendingTombstones(): Promise<boolean>;
79
+ claimRevalidation(keyHash: string, activeRevision: number, cacheKey: string, objectKeyPrefix: string, now: number, leaseMs: number): Promise<RevalidationClaim | null>;
80
+ private reserveRevision;
81
+ reserveWrite(keyHash: string, cacheKey: string, objectKeyPrefix: string, createdAt: number): Promise<WriteReservation>;
82
+ replaceFailedWrite(keyHash: string, cacheKey: string, objectKeyPrefix: string, failedObjectKey: string, fenceTags: string[], createdAt: number): Promise<WriteReservation | null>;
83
+ reserveRegeneration(keyHash: string, cacheKey: string, objectKeyPrefix: string, createdAt: number): Promise<RegenerationReservation | null>;
84
+ publish(keyHash: string, revision: number, metadata: CandidateMetadata, claimId?: string, reservationObjectKey?: string): Promise<PublicationResult>;
85
+ invalidatePublishedRevision(keyHash: string, revision: number): Promise<TombstoneDrainResult>;
86
+ getEntry(keyHash: string): StoredEntry | null;
87
+ private getTagInvalidationMaximum;
88
+ getTagExpiration(tags: string[]): number;
89
+ reserveRefresh(options: ResponseStoreRefreshOptions, objectKeyRoot: string, createdAt: number): Promise<RefreshCandidate[]>;
90
+ purgeMatching(options: ResponseStorePurgeOptions, invalidatedAt?: number): Promise<PurgeReservation>;
91
+ private writeR2Tombstone;
92
+ private finishCompletedTombstones;
93
+ drainPendingTombstones(limit: number, keyHash?: string, afterKeyHash?: string): Promise<TombstoneDrainResult>;
94
+ listPendingEdgePurges(limit: number): PurgedEntry[];
95
+ markTombstonesEdgePurged(entries: PurgedEntry[]): void;
96
+ inspect(): StoredEntry[];
97
+ }
98
+ //#endregion