@opennextjs/cloudflare 0.5.11 → 0.6.0

package/dist/api/durable-objects/queue.spec.js

@@ -0,0 +1,290 @@
+import { describe, expect, it, vi } from "vitest";
+import { DurableObjectQueueHandler } from "./queue";
+vi.mock("cloudflare:workers", () => ({
+    DurableObject: class {
+        ctx;
+        env;
+        constructor(ctx, env) {
+            this.ctx = ctx;
+            this.env = env;
+        }
+    },
+}));
+const createDurableObjectQueue = ({ fetchDuration, statusCode, headers, disableSQLite, }) => {
+    const mockState = {
+        waitUntil: vi.fn(),
+        blockConcurrencyWhile: vi.fn().mockImplementation(async (fn) => fn()),
+        storage: {
+            setAlarm: vi.fn(),
+            getAlarm: vi.fn(),
+            sql: {
+                exec: vi.fn().mockImplementation(() => ({
+                    one: vi.fn(),
+                })),
+            },
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new DurableObjectQueueHandler(mockState, {
+        WORKER_SELF_REFERENCE: {
+            fetch: vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(new Response(null, {
+                status: statusCode,
+                headers: headers ?? new Headers([["x-nextjs-cache", "REVALIDATED"]]),
+            })), fetchDuration))),
+            connect: vi.fn(),
+        },
+        NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE: disableSQLite ? "true" : undefined,
+    });
+};
+const createMessage = (dedupId, lastModified = Date.now()) => ({
+    MessageBody: { host: "test.local", url: "/test", eTag: "test", lastModified },
+    MessageGroupId: "test.local/test",
+    MessageDeduplicationId: dedupId,
+    previewModeId: "test",
+});
+describe("DurableObjectQueue", () => {
+    describe("successful revalidation", () => {
+        it("should process a single revalidation", async () => {
+            process.env.__NEXT_PREVIEW_MODE_ID = "test";
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            const firstRequest = await queue.revalidate(createMessage("id"));
+            expect(firstRequest).toBeUndefined();
+            expect(queue.ongoingRevalidations.size).toBe(1);
+            expect(queue.ongoingRevalidations.has("id")).toBe(true);
+            await queue.ongoingRevalidations.get("id");
+            expect(queue.ongoingRevalidations.size).toBe(0);
+            expect(queue.ongoingRevalidations.has("id")).toBe(false);
+            expect(queue.service.fetch).toHaveBeenCalledWith("https://test.local/test", {
+                method: "HEAD",
+                headers: {
+                    "x-prerender-revalidate": "test",
+                    "x-isr": "1",
+                },
+                signal: expect.any(AbortSignal),
+            });
+        });
+        it("should dedupe revalidations", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.revalidate(createMessage("id"));
+            await queue.revalidate(createMessage("id"));
+            expect(queue.ongoingRevalidations.size).toBe(1);
+            expect(queue.ongoingRevalidations.has("id")).toBe(true);
+        });
+        it("should block concurrency", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.revalidate(createMessage("id"));
+            await queue.revalidate(createMessage("id2"));
+            await queue.revalidate(createMessage("id3"));
+            await queue.revalidate(createMessage("id4"));
+            await queue.revalidate(createMessage("id5"));
+            // the next one should block until one of the previous ones finishes
+            const blockedReq = queue.revalidate(createMessage("id6"));
+            expect(queue.ongoingRevalidations.size).toBe(queue.maxRevalidations);
+            expect(queue.ongoingRevalidations.has("id6")).toBe(false);
+            expect(Array.from(queue.ongoingRevalidations.keys())).toEqual(["id", "id2", "id3", "id4", "id5"]);
+            // BlockConcurrencyWhile is called twice here, first time during creation of the object and second time when we try to revalidate
+            // @ts-expect-error
+            expect(queue.ctx.blockConcurrencyWhile).toHaveBeenCalledTimes(2);
+            // Here we await the blocked request to ensure it's resolved
+            await blockedReq;
+            // We then need to await for the actual revalidation to finish
+            await Promise.all(Array.from(queue.ongoingRevalidations.values()));
+            expect(queue.ongoingRevalidations.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(6);
+        });
+    });
+    describe("failed revalidation", () => {
+        it("should not put it in failed state for an incorrect 200", async () => {
+            const queue = createDurableObjectQueue({
+                fetchDuration: 10,
+                statusCode: 200,
+                headers: new Headers([["x-nextjs-cache", "MISS"]]),
+            });
+            await queue.revalidate(createMessage("id"));
+            await queue.ongoingRevalidations.get("id");
+            expect(queue.routeInFailedState.size).toBe(0);
+        });
+        it("should not put it in failed state for a failed revalidation with 404", async () => {
+            const queue = createDurableObjectQueue({
+                fetchDuration: 10,
+                statusCode: 404,
+            });
+            await queue.revalidate(createMessage("id"));
+            await queue.ongoingRevalidations.get("id");
+            expect(queue.routeInFailedState.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+            await queue.revalidate(createMessage("id"));
+            expect(queue.routeInFailedState.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
+        });
+        it("should put it in failed state if revalidation fails with 500", async () => {
+            const queue = createDurableObjectQueue({
+                fetchDuration: 10,
+                statusCode: 500,
+            });
+            await queue.revalidate(createMessage("id"));
+            await queue.ongoingRevalidations.get("id");
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.routeInFailedState.has("id")).toBe(true);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+            await queue.revalidate(createMessage("id"));
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+        });
+        it("should put it in failed state if revalidation fetch throw", async () => {
+            const queue = createDurableObjectQueue({
+                fetchDuration: 10,
+            });
+            // @ts-expect-error - This is mocked above
+            queue.service.fetch.mockImplementationOnce(() => Promise.reject(new Error("fetch error")));
+            await queue.revalidate(createMessage("id"));
+            await queue.ongoingRevalidations.get("id");
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.routeInFailedState.has("id")).toBe(true);
+            expect(queue.ongoingRevalidations.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+            await queue.revalidate(createMessage("id"));
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("addAlarm", () => {
+        const getStorage = (queue) => {
+            // @ts-expect-error - ctx is a protected field
+            return queue.ctx.storage;
+        };
+        it("should not add an alarm if there are no failed states", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.addAlarm();
+            expect(getStorage(queue).setAlarm).not.toHaveBeenCalled();
+        });
+        it("should add an alarm if there are failed states", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            const nextAlarmMs = Date.now() + 1000;
+            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs });
+            await queue.addAlarm();
+            expect(getStorage(queue).setAlarm).toHaveBeenCalledWith(nextAlarmMs);
+        });
+        it("should not add an alarm if there is already an alarm set", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs: 1000 });
+            // @ts-expect-error
+            queue.ctx.storage.getAlarm.mockResolvedValueOnce(1000);
+            await queue.addAlarm();
+            expect(getStorage(queue).setAlarm).not.toHaveBeenCalled();
+        });
+        it("should set the alarm to the lowest nextAlarm", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            const nextAlarmMs = Date.now() + 1000;
+            const firstAlarm = Date.now() + 500;
+            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 0, nextAlarmMs });
+            queue.routeInFailedState.set("id2", {
+                msg: createMessage("id2"),
+                retryCount: 0,
+                nextAlarmMs: firstAlarm,
+            });
+            await queue.addAlarm();
+            expect(getStorage(queue).setAlarm).toHaveBeenCalledWith(firstAlarm);
+        });
+    });
+    describe("addToFailedState", () => {
+        it("should add a failed state", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.addToFailedState(createMessage("id"));
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.routeInFailedState.has("id")).toBe(true);
+            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(1);
+        });
+        it("should add a failed state with the correct nextAlarm", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.addToFailedState(createMessage("id"));
+            expect(queue.routeInFailedState.get("id")?.nextAlarmMs).toBeGreaterThan(Date.now());
+            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(1);
+        });
+        it("should add a failed state with the correct nextAlarm for a retry", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            await queue.addToFailedState(createMessage("id"));
+            await queue.addToFailedState(createMessage("id"));
+            expect(queue.routeInFailedState.get("id")?.nextAlarmMs).toBeGreaterThan(Date.now());
+            expect(queue.routeInFailedState.get("id")?.retryCount).toBe(2);
+        });
+        it("should not add a failed state if it has been retried 6 times", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            queue.routeInFailedState.set("id", { msg: createMessage("id"), retryCount: 6, nextAlarmMs: 1000 });
+            await queue.addToFailedState(createMessage("id"));
+            expect(queue.routeInFailedState.size).toBe(0);
+        });
+    });
+    describe("alarm", () => {
+        it("should execute revalidations for expired events", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            queue.routeInFailedState.set("id", {
+                msg: createMessage("id"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() - 1000,
+            });
+            queue.routeInFailedState.set("id2", {
+                msg: createMessage("id2"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() - 1000,
+            });
+            await queue.alarm();
+            expect(queue.routeInFailedState.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
+        });
+        it("should execute revalidations for the next event to retry", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            queue.routeInFailedState.set("id", {
+                msg: createMessage("id"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() + 1000,
+            });
+            queue.routeInFailedState.set("id2", {
+                msg: createMessage("id2"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() + 500,
+            });
+            await queue.alarm();
+            expect(queue.routeInFailedState.size).toBe(1);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(1);
+            expect(queue.routeInFailedState.has("id2")).toBe(false);
+        });
+        it("should execute revalidations for the next event to retry and expired events", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10 });
+            queue.routeInFailedState.set("id", {
+                msg: createMessage("id"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() + 1000,
+            });
+            queue.routeInFailedState.set("id2", {
+                msg: createMessage("id2"),
+                retryCount: 0,
+                nextAlarmMs: Date.now() - 1000,
+            });
+            await queue.alarm();
+            expect(queue.routeInFailedState.size).toBe(0);
+            expect(queue.service.fetch).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("disableSQLite", () => {
+        it("should not initialize the sqlite storage", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
+            expect(queue.sql.exec).not.toHaveBeenCalled();
+        });
+        it("should not write to the sqlite storage on failed state", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
+            await queue.addToFailedState(createMessage("id"));
+            expect(queue.sql.exec).not.toHaveBeenCalled();
+        });
+        it("should not read from the sqlite storage on checkSyncTable", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
+            queue.checkSyncTable(createMessage("id"));
+            expect(queue.sql.exec).not.toHaveBeenCalled();
+        });
+        it("should not write to sql on successful revalidation", async () => {
+            const queue = createDurableObjectQueue({ fetchDuration: 10, disableSQLite: true });
+            await queue.revalidate(createMessage("id"));
+            expect(queue.sql.exec).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/api/durable-objects/sharded-tag-cache.d.ts

@@ -0,0 +1,7 @@
+import { DurableObject } from "cloudflare:workers";
+export declare class DOShardedTagCache extends DurableObject<CloudflareEnv> {
+    sql: SqlStorage;
+    constructor(state: DurableObjectState, env: CloudflareEnv);
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    writeTags(tags: string[], lastModified: number): Promise<void>;
+}

package/dist/api/durable-objects/sharded-tag-cache.js

@@ -0,0 +1,22 @@
+import { DurableObject } from "cloudflare:workers";
+export class DOShardedTagCache extends DurableObject {
+    sql;
+    constructor(state, env) {
+        super(state, env);
+        this.sql = state.storage.sql;
+        state.blockConcurrencyWhile(async () => {
+            this.sql.exec(`CREATE TABLE IF NOT EXISTS revalidations (tag TEXT PRIMARY KEY, revalidatedAt INTEGER)`);
+        });
+    }
+    async hasBeenRevalidated(tags, lastModified) {
+        const result = this.sql
+            .exec(`SELECT COUNT(*) as cnt FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ?`, ...tags, lastModified ?? Date.now())
+            .one();
+        return result.cnt > 0;
+    }
+    async writeTags(tags, lastModified) {
+        tags.forEach((tag) => {
+            this.sql.exec(`INSERT OR REPLACE INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`, tag, lastModified);
+        });
+    }
+}

package/dist/api/durable-objects/sharded-tag-cache.spec.js

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import { DOShardedTagCache } from "./sharded-tag-cache";
+vi.mock("cloudflare:workers", () => ({
+    DurableObject: class {
+        ctx;
+        env;
+        constructor(ctx, env) {
+            this.ctx = ctx;
+            this.env = env;
+        }
+    },
+}));
+const createDOShardedTagCache = () => {
+    const mockState = {
+        waitUntil: vi.fn(),
+        blockConcurrencyWhile: vi.fn().mockImplementation(async (fn) => fn()),
+        storage: {
+            setAlarm: vi.fn(),
+            getAlarm: vi.fn(),
+            sql: {
+                exec: vi.fn().mockImplementation(() => ({
+                    one: vi.fn(),
+                })),
+            },
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new DOShardedTagCache(mockState, {});
+};
+describe("DOShardedTagCache class", () => {
+    it("should block concurrency while creating the table", async () => {
+        const cache = createDOShardedTagCache();
+        // @ts-expect-error - testing private method
+        expect(cache.ctx.blockConcurrencyWhile).toHaveBeenCalled();
+        expect(cache.sql.exec).toHaveBeenCalledWith(`CREATE TABLE IF NOT EXISTS revalidations (tag TEXT PRIMARY KEY, revalidatedAt INTEGER)`);
+    });
+});

package/dist/api/overrides/incremental-cache/internal.d.ts

@@ -0,0 +1,5 @@
+import { CacheValue } from "@opennextjs/aws/types/overrides.js";
+export type IncrementalCacheEntry<IsFetch extends boolean> = {
+    value: CacheValue<IsFetch>;
+    lastModified: number;
+};

package/dist/api/{kv-cache.d.ts → overrides/incremental-cache/kv-incremental-cache.d.ts}

@@ -5,7 +5,7 @@ export declare const STATUS_DELETED = 1;
  * Open Next cache based on cloudflare KV and Assets.
  *
  * Note: The class is instantiated outside of the request context.
- * The cloudflare context and process.env are not initialzed yet
+ * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
 declare class Cache implements IncrementalCache {

package/dist/api/{kv-cache.js → overrides/incremental-cache/kv-incremental-cache.js}

@@ -1,19 +1,19 @@
 import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "./cloudflare-context.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
 export const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
 export const STATUS_DELETED = 1;
 /**
  * Open Next cache based on cloudflare KV and Assets.
  *
  * Note: The class is instantiated outside of the request context.
- * The cloudflare context and process.env are not initialzed yet
+ * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
 class Cache {
     name = "cloudflare-kv";
     async get(key, isFetch) {
         const cfEnv = getCloudflareContext().env;
-        const kv = cfEnv.NEXT_CACHE_WORKERS_KV;
+        const kv = cfEnv.NEXT_INC_CACHE_KV;
         const assets = cfEnv.ASSETS;
         if (!(kv || assets)) {
             throw new IgnorableError(`No KVNamespace nor Fetcher`);
@@ -67,7 +67,7 @@ class Cache {
         }
     }
     async set(key, value, isFetch) {
-        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
         if (!kv) {
             throw new IgnorableError(`No KVNamespace`);
         }
@@ -89,7 +89,7 @@ class Cache {
         }
     }
     async delete(key) {
-        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
         if (!kv) {
             throw new IgnorableError(`No KVNamespace`);
         }

package/dist/api/overrides/incremental-cache/r2-incremental-cache.d.ts

@@ -0,0 +1,17 @@
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+/**
+ * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
+ * underlying data store.
+ *
+ * The directory that the cache entries are stored in can be configured with the `NEXT_INC_CACHE_R2_PREFIX`
+ * environment variable, and defaults to `incremental-cache`.
+ */
+declare class R2IncrementalCache implements IncrementalCache {
+    readonly name = "r2-incremental-cache";
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    protected getR2Key(key: string, isFetch?: boolean): string;
+}
+declare const _default: R2IncrementalCache;
+export default _default;

package/dist/api/overrides/incremental-cache/r2-incremental-cache.js

@@ -0,0 +1,61 @@
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+/**
+ * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
+ * underlying data store.
+ *
+ * The directory that the cache entries are stored in can be configured with the `NEXT_INC_CACHE_R2_PREFIX`
+ * environment variable, and defaults to `incremental-cache`.
+ */
+class R2IncrementalCache {
+    name = "r2-incremental-cache";
+    async get(key, isFetch) {
+        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        if (!r2)
+            throw new IgnorableError("No R2 bucket");
+        debug(`Get ${key}`);
+        try {
+            const r2Object = await r2.get(this.getR2Key(key, isFetch));
+            if (!r2Object)
+                return null;
+            return {
+                value: await r2Object.json(),
+                lastModified: r2Object.uploaded.getTime(),
+            };
+        }
+        catch (e) {
+            error("Failed to get from cache", e);
+            return null;
+        }
+    }
+    async set(key, value, isFetch) {
+        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        if (!r2)
+            throw new IgnorableError("No R2 bucket");
+        debug(`Set ${key}`);
+        try {
+            await r2.put(this.getR2Key(key, isFetch), JSON.stringify(value));
+        }
+        catch (e) {
+            error("Failed to set to cache", e);
+        }
+    }
+    async delete(key) {
+        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        if (!r2)
+            throw new IgnorableError("No R2 bucket");
+        debug(`Delete ${key}`);
+        try {
+            await r2.delete(this.getR2Key(key));
+        }
+        catch (e) {
+            error("Failed to delete from cache", e);
+        }
+    }
+    getR2Key(key, isFetch) {
+        const directory = getCloudflareContext().env.NEXT_INC_CACHE_R2_PREFIX ?? "incremental-cache";
+        return `${directory}/${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`;
+    }
+}
+export default new R2IncrementalCache();

package/dist/api/overrides/incremental-cache/regional-cache.d.ts

@@ -0,0 +1,51 @@
+import { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+import { IncrementalCacheEntry } from "./internal.js";
+type Options = {
+    /**
+     * The mode to use for the regional cache.
+     *
+     * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+     * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
+     */
+    mode: "short-lived" | "long-lived";
+    /**
+     * Whether the regional cache entry should be updated in the background or not when it experiences
+     * a cache hit.
+     *
+     * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+     */
+    shouldLazilyUpdateOnCacheHit?: boolean;
+};
+declare class RegionalCache implements IncrementalCache {
+    private store;
+    private opts;
+    name: string;
+    protected localCache: Cache | undefined;
+    constructor(store: IncrementalCache, opts: Options);
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    protected getCacheInstance(): Promise<Cache>;
+    protected getCacheKey(key: string, isFetch?: boolean): Request<unknown, CfProperties<unknown>>;
+    protected putToCache(key: Request, entry: IncrementalCacheEntry<boolean>): Promise<void>;
+}
+/**
+ * A regional cache will wrap an incremental cache and provide faster cache lookups for an entry
+ * when making requests within the region.
+ *
+ * The regional cache uses the Cache API.
+ *
+ * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * a request is made to another region that has an entry stored in its regional cache.
+ *
+ * @param cache - Incremental cache instance.
+ * @param opts.mode - The mode to use for the regional cache.
+ * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
+ * the background or not when it experiences a cache hit.
+ *
+ * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ */
+export declare function withRegionalCache(cache: IncrementalCache, opts: Options): RegionalCache;
+export {};

package/dist/api/overrides/incremental-cache/regional-cache.js

@@ -0,0 +1,111 @@
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+const ONE_MINUTE_IN_SECONDS = 60;
+const THIRTY_MINUTES_IN_SECONDS = ONE_MINUTE_IN_SECONDS * 30;
+class RegionalCache {
+    store;
+    opts;
+    name;
+    localCache;
+    constructor(store, opts) {
+        this.store = store;
+        this.opts = opts;
+        this.name = this.store.name;
+        this.opts.shouldLazilyUpdateOnCacheHit ??= this.opts.mode === "long-lived";
+    }
+    async get(key, isFetch) {
+        try {
+            const cache = await this.getCacheInstance();
+            const localCacheKey = this.getCacheKey(key, isFetch);
+            // Check for a cached entry as this will be faster than the store response.
+            const cachedResponse = await cache.match(localCacheKey);
+            if (cachedResponse) {
+                debug("Get - cached response");
+                // Re-fetch from the store and update the regional cache in the background
+                if (this.opts.shouldLazilyUpdateOnCacheHit) {
+                    getCloudflareContext().ctx.waitUntil(this.store.get(key, isFetch).then(async (rawEntry) => {
+                        const { value, lastModified } = rawEntry ?? {};
+                        if (value && typeof lastModified === "number") {
+                            await this.putToCache(localCacheKey, { value, lastModified });
+                        }
+                    }));
+                }
+                return cachedResponse.json();
+            }
+            const rawEntry = await this.store.get(key, isFetch);
+            const { value, lastModified } = rawEntry ?? {};
+            if (!value || typeof lastModified !== "number")
+                return null;
+            // Update the locale cache after retrieving from the store.
+            getCloudflareContext().ctx.waitUntil(this.putToCache(localCacheKey, { value, lastModified }));
+            return { value, lastModified };
+        }
+        catch (e) {
+            error("Failed to get from regional cache", e);
+            return null;
+        }
+    }
+    async set(key, value, isFetch) {
+        try {
+            await this.store.set(key, value, isFetch);
+            await this.putToCache(this.getCacheKey(key, isFetch), {
+                value,
+                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                //       See https://developers.cloudflare.com/workers/reference/security-model/
+                lastModified: Date.now(),
+            });
+        }
+        catch (e) {
+            error(`Failed to get from regional cache`, e);
+        }
+    }
+    async delete(key) {
+        try {
+            await this.store.delete(key);
+            const cache = await this.getCacheInstance();
+            await cache.delete(this.getCacheKey(key));
+        }
+        catch (e) {
+            error("Failed to delete from regional cache", e);
+        }
+    }
+    async getCacheInstance() {
+        if (this.localCache)
+            return this.localCache;
+        this.localCache = await caches.open("incremental-cache");
+        return this.localCache;
+    }
+    getCacheKey(key, isFetch) {
+        return new Request(new URL(`${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`, "http://cache.local"));
+    }
+    async putToCache(key, entry) {
+        const cache = await this.getCacheInstance();
+        const age = this.opts.mode === "short-lived"
+            ? ONE_MINUTE_IN_SECONDS
+            : entry.value.revalidate || THIRTY_MINUTES_IN_SECONDS;
+        await cache.put(key, new Response(JSON.stringify(entry), {
+            headers: new Headers({ "cache-control": `max-age=${age}` }),
+        }));
+    }
+}
+/**
+ * A regional cache will wrap an incremental cache and provide faster cache lookups for an entry
+ * when making requests within the region.
+ *
+ * The regional cache uses the Cache API.
+ *
+ * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * a request is made to another region that has an entry stored in its regional cache.
+ *
+ * @param cache - Incremental cache instance.
+ * @param opts.mode - The mode to use for the regional cache.
+ * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
+ * the background or not when it experiences a cache hit.
+ *
+ * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ */
+export function withRegionalCache(cache, opts) {
+    return new RegionalCache(cache, opts);
+}

package/dist/api/overrides/queue/do-queue.d.ts

@@ -0,0 +1,6 @@
+import type { QueueMessage } from "@opennextjs/aws/types/overrides";
+declare const _default: {
+    name: string;
+    send: (msg: QueueMessage) => Promise<void>;
+};
+export default _default;