@opennextjs/cloudflare 1.0.4 → 1.1.0

package/dist/api/cloudflare-context.d.ts

@@ -1,4 +1,5 @@
 import type { GetPlatformProxyOptions } from "wrangler";
+import type { BucketCachePurge } from "./durable-objects/bucket-cache-purge.js";
 import type { DOQueueHandler } from "./durable-objects/queue.js";
 import type { DOShardedTagCache } from "./durable-objects/sharded-tag-cache.js";
 import type { PREFIX_ENV_NAME as KV_CACHE_PREFIX_ENV_NAME } from "./overrides/incremental-cache/kv-incremental-cache.js";
@@ -21,6 +22,10 @@ declare global {
         NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS?: string;
         NEXT_CACHE_DO_QUEUE_MAX_RETRIES?: string;
         NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE?: string;
+        NEXT_CACHE_DO_PURGE?: DurableObjectNamespace<BucketCachePurge>;
+        NEXT_CACHE_DO_PURGE_BUFFER_TIME_IN_SECONDS?: string;
+        CACHE_PURGE_ZONE_ID?: string;
+        CACHE_PURGE_API_TOKEN?: string;
     }
 }
 export type CloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext> = {

package/dist/api/config.d.ts

@@ -1,6 +1,6 @@
 import type { BuildOptions } from "@opennextjs/aws/build/helper";
 import { BaseOverride, LazyLoadedOverride, OpenNextConfig as AwsOpenNextConfig } from "@opennextjs/aws/types/open-next";
-import type { IncrementalCache, Queue, TagCache } from "@opennextjs/aws/types/overrides";
+import type { CDNInvalidationHandler, IncrementalCache, Queue, TagCache } from "@opennextjs/aws/types/overrides";
 export type Override<T extends BaseOverride> = "dummy" | T | LazyLoadedOverride<T>;
 /**
  * Cloudflare specific overrides.
@@ -20,6 +20,10 @@ export type CloudflareOverrides = {
      * Sets the revalidation queue implementation
      */
     queue?: "direct" | Override<Queue>;
+    /**
+     * Sets the automatic cache purge implementation
+     */
+    cachePurge?: Override<CDNInvalidationHandler>;
     /**
      * Enable cache interception
      * Should be `false` when PPR is used

package/dist/api/config.js

@@ -5,7 +5,7 @@
  * @returns the OpenNext configuration object
  */
 export function defineCloudflareConfig(config = {}) {
-    const { incrementalCache, tagCache, queue, enableCacheInterception = false } = config;
+    const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false } = config;
     return {
         default: {
             override: {
@@ -15,6 +15,7 @@ export function defineCloudflareConfig(config = {}) {
                 incrementalCache: resolveIncrementalCache(incrementalCache),
                 tagCache: resolveTagCache(tagCache),
                 queue: resolveQueue(queue),
+                cdnInvalidation: resolveCdnInvalidation(cachePurge),
             },
             routePreloadingBehavior: "withWaitUntil",
         },
@@ -57,6 +58,12 @@ function resolveQueue(value = "dummy") {
     }
     return typeof value === "function" ? value : () => value;
 }
+function resolveCdnInvalidation(value = "dummy") {
+    if (typeof value === "string") {
+        return value;
+    }
+    return typeof value === "function" ? value : () => value;
+}
 /**
  * @param buildOpts build options from AWS
  * @returns The OpenConfig specific to cloudflare

package/dist/api/durable-objects/bucket-cache-purge.d.ts

@@ -0,0 +1,7 @@
+import { DurableObject } from "cloudflare:workers";
+export declare class BucketCachePurge extends DurableObject<CloudflareEnv> {
+    bufferTimeInSeconds: number;
+    constructor(state: DurableObjectState, env: CloudflareEnv);
+    purgeCacheByTags(tags: string[]): Promise<void>;
+    alarm(): Promise<void>;
+}

package/dist/api/durable-objects/bucket-cache-purge.js

@@ -0,0 +1,75 @@
+import { DurableObject } from "cloudflare:workers";
+import { internalPurgeCacheByTags } from "../overrides/internal";
+const DEFAULT_BUFFER_TIME_IN_SECONDS = 5;
+// https://developers.cloudflare.com/cache/how-to/purge-cache/#hostname-tag-prefix-url-and-purge-everything-limits
+const MAX_NUMBER_OF_TAGS_PER_PURGE = 100;
+export class BucketCachePurge extends DurableObject {
+    bufferTimeInSeconds;
+    constructor(state, env) {
+        super(state, env);
+        this.bufferTimeInSeconds = env.NEXT_CACHE_DO_PURGE_BUFFER_TIME_IN_SECONDS
+            ? parseInt(env.NEXT_CACHE_DO_PURGE_BUFFER_TIME_IN_SECONDS)
+            : DEFAULT_BUFFER_TIME_IN_SECONDS; // Default buffer time
+        // Initialize the sql table if it doesn't exist
+        state.blockConcurrencyWhile(async () => {
+            state.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS cache_purge (
+        tag TEXT NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS tag_index ON cache_purge (tag);
+      `);
+        });
+    }
+    async purgeCacheByTags(tags) {
+        for (const tag of tags) {
+            // Insert the tag into the sql table
+            this.ctx.storage.sql.exec(`
+        INSERT OR REPLACE INTO cache_purge (tag)
+        VALUES (?)`, [tag]);
+        }
+        const nextAlarm = await this.ctx.storage.getAlarm();
+        if (!nextAlarm) {
+            // Set an alarm to trigger the cache purge
+            this.ctx.storage.setAlarm(Date.now() + this.bufferTimeInSeconds * 1000);
+        }
+    }
+    async alarm() {
+        let tags = this.ctx.storage.sql
+            .exec(`
+      SELECT * FROM cache_purge LIMIT ${MAX_NUMBER_OF_TAGS_PER_PURGE}
+    `)
+            .toArray();
+        do {
+            if (tags.length === 0) {
+                // No tags to purge, we can stop
+                return;
+            }
+            const result = await internalPurgeCacheByTags(this.env, tags.map((row) => row.tag));
+            // For every other error, we just remove the tags from the sql table
+            // and continue
+            if (result === "rate-limit-exceeded") {
+                // Rate limit exceeded, we need to wait for the next alarm
+                // and try again
+                // We throw here to take advantage of the built-in retry
+                throw new Error("Rate limit exceeded");
+            }
+            // Delete the tags from the sql table
+            this.ctx.storage.sql.exec(`
+        DELETE FROM cache_purge
+        WHERE tag IN (${tags.map(() => "?").join(",")})
+      `, tags.map((row) => row.tag));
+            if (tags.length < MAX_NUMBER_OF_TAGS_PER_PURGE) {
+                // If we have less than MAX_NUMBER_OF_TAGS_PER_PURGE tags, we can stop
+                tags = [];
+            }
+            else {
+                // Otherwise, we need to get the next 100 tags
+                tags = this.ctx.storage.sql
+                    .exec(`
+          SELECT * FROM cache_purge LIMIT ${MAX_NUMBER_OF_TAGS_PER_PURGE}
+        `)
+                    .toArray();
+            }
+        } while (tags.length >= 0);
+    }
+}

package/dist/api/durable-objects/bucket-cache-purge.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/durable-objects/bucket-cache-purge.spec.js

@@ -0,0 +1,121 @@
+import { describe, expect, it, vi } from "vitest";
+import * as internal from "../overrides/internal";
+import { BucketCachePurge } from "./bucket-cache-purge";
+vi.mock("cloudflare:workers", () => ({
+    DurableObject: class {
+        ctx;
+        env;
+        constructor(ctx, env) {
+            this.ctx = ctx;
+            this.env = env;
+        }
+    },
+}));
+const createBucketCachePurge = () => {
+    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(),
+                    toArray: vi.fn().mockReturnValue([]),
+                })),
+            },
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new BucketCachePurge(mockState, {});
+};
+describe("BucketCachePurge", () => {
+    it("should block concurrency while creating the table", async () => {
+        const cache = createBucketCachePurge();
+        // @ts-expect-error - testing private method
+        expect(cache.ctx.blockConcurrencyWhile).toHaveBeenCalled();
+        // @ts-expect-error - testing private method
+        expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("CREATE TABLE IF NOT EXISTS cache_purge"));
+    });
+    describe("purgeCacheByTags", () => {
+        it("should insert tags into the sql table", async () => {
+            const cache = createBucketCachePurge();
+            const tags = ["tag1", "tag2"];
+            await cache.purgeCacheByTags(tags);
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("INSERT OR REPLACE INTO cache_purge"), [tags[0]]);
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("INSERT OR REPLACE INTO cache_purge"), [tags[1]]);
+        });
+        it("should set an alarm if no alarm is set", async () => {
+            const cache = createBucketCachePurge();
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.getAlarm.mockResolvedValueOnce(null);
+            await cache.purgeCacheByTags(["tag"]);
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.setAlarm).toHaveBeenCalled();
+        });
+        it("should not set an alarm if one is already set", async () => {
+            const cache = createBucketCachePurge();
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.getAlarm.mockResolvedValueOnce(true);
+            await cache.purgeCacheByTags(["tag"]);
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.setAlarm).not.toHaveBeenCalled();
+        });
+    });
+    describe("alarm", () => {
+        it("should purge cache by tags and delete them from the sql table", async () => {
+            const cache = createBucketCachePurge();
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.sql.exec.mockReturnValueOnce({
+                toArray: () => [{ tag: "tag1" }, { tag: "tag2" }],
+            });
+            await cache.alarm();
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledWith(expect.stringContaining("DELETE FROM cache_purge"), ["tag1", "tag2"]);
+        });
+        it("should not purge cache if no tags are found", async () => {
+            const cache = createBucketCachePurge();
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.sql.exec.mockReturnValueOnce({
+                toArray: () => [],
+            });
+            await cache.alarm();
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.sql.exec).not.toHaveBeenCalledWith(expect.stringContaining("DELETE FROM cache_purge"), []);
+        });
+        it("should call internalPurgeCacheByTags with the correct tags", async () => {
+            const cache = createBucketCachePurge();
+            const tags = ["tag1", "tag2"];
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.sql.exec.mockReturnValueOnce({
+                toArray: () => tags.map((tag) => ({ tag })),
+            });
+            const internalPurgeCacheByTagsSpy = vi.spyOn(internal, "internalPurgeCacheByTags");
+            await cache.alarm();
+            expect(internalPurgeCacheByTagsSpy).toHaveBeenCalledWith(
+            // @ts-expect-error - testing private method
+            cache.env, tags);
+            // @ts-expect-error - testing private method 1st is constructor, 2nd is to get the tags and 3rd is to delete them
+            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledTimes(3);
+        });
+        it("should continue until all tags are purged", async () => {
+            const cache = createBucketCachePurge();
+            const tags = Array.from({ length: 100 }, (_, i) => `tag${i}`);
+            // @ts-expect-error - testing private method
+            cache.ctx.storage.sql.exec.mockReturnValueOnce({
+                toArray: () => tags.map((tag) => ({ tag })),
+            });
+            const internalPurgeCacheByTagsSpy = vi.spyOn(internal, "internalPurgeCacheByTags");
+            await cache.alarm();
+            expect(internalPurgeCacheByTagsSpy).toHaveBeenCalledWith(
+            // @ts-expect-error - testing private method
+            cache.env, tags);
+            // @ts-expect-error - testing private method 1st is constructor, 2nd is to get the tags and 3rd is to delete them, 4th is to get the next 100 tags
+            expect(cache.ctx.storage.sql.exec).toHaveBeenCalledTimes(4);
+            // @ts-expect-error - testing private method
+            expect(cache.ctx.storage.sql.exec).toHaveBeenLastCalledWith(expect.stringContaining("SELECT * FROM cache_purge LIMIT 100"));
+        });
+    });
+});

package/dist/api/overrides/cache-purge/index.d.ts

@@ -0,0 +1,12 @@
+interface PurgeOptions {
+    type: "durableObject" | "direct";
+}
+export declare const purgeCache: ({ type }: PurgeOptions) => {
+    name: string;
+    invalidatePaths(paths: {
+        initialPath: string;
+        rawPath: string;
+        resolvedRoutes: import("@opennextjs/aws/types/open-next").ResolvedRoute[];
+    }[]): Promise<void>;
+};
+export {};

package/dist/api/overrides/cache-purge/index.js

@@ -0,0 +1,26 @@
+import { getCloudflareContext } from "../../cloudflare-context";
+import { debugCache, internalPurgeCacheByTags } from "../internal.js";
+export const purgeCache = ({ type = "direct" }) => {
+    return {
+        name: "cloudflare",
+        async invalidatePaths(paths) {
+            const { env } = getCloudflareContext();
+            const tags = paths.map((path) => `_N_T_${path.rawPath}`);
+            debugCache("cdnInvalidation", "Invalidating paths:", tags);
+            if (type === "direct") {
+                await internalPurgeCacheByTags(env, tags);
+            }
+            else {
+                const durableObject = env.NEXT_CACHE_DO_PURGE;
+                if (!durableObject) {
+                    debugCache("cdnInvalidation", "No durable object found. Skipping cache purge.");
+                    return;
+                }
+                const id = durableObject.idFromName("cache-purge");
+                const obj = durableObject.get(id);
+                await obj.purgeCacheByTags(tags);
+            }
+            debugCache("cdnInvalidation", "Invalidated paths:", tags);
+        },
+    };
+};

package/dist/api/overrides/internal.d.ts

@@ -12,3 +12,5 @@ export type KeyOptions = {
     buildId: string | undefined;
 };
 export declare function computeCacheKey(key: string, options: KeyOptions): string;
+export declare function purgeCacheByTags(tags: string[]): Promise<void>;
+export declare function internalPurgeCacheByTags(env: CloudflareEnv, tags: string[]): Promise<"missing-credentials" | "rate-limit-exceeded" | "purge-failed" | "purge-success">;

package/dist/api/overrides/internal.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { getCloudflareContext } from "../cloudflare-context.js";
 export const debugCache = (name, ...args) => {
     if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
         console.log(`[${name}] `, ...args);
@@ -11,3 +12,54 @@ export function computeCacheKey(key, options) {
     const hash = createHash("sha256").update(key).digest("hex");
     return `${prefix}/${buildId}/${hash}.${cacheType}`.replace(/\/+/g, "/");
 }
+export async function purgeCacheByTags(tags) {
+    const { env } = getCloudflareContext();
+    // We have a durable object for purging cache
+    // We should use it
+    if (env.NEXT_CACHE_DO_PURGE) {
+        const durableObject = env.NEXT_CACHE_DO_PURGE;
+        const id = durableObject.idFromName("cache-purge");
+        const obj = durableObject.get(id);
+        await obj.purgeCacheByTags(tags);
+    }
+    else {
+        // We don't have a durable object for purging cache
+        // We should use the API directly
+        await internalPurgeCacheByTags(env, tags);
+    }
+}
+export async function internalPurgeCacheByTags(env, tags) {
+    if (!env.CACHE_PURGE_ZONE_ID && !env.CACHE_PURGE_API_TOKEN) {
+        // THIS IS A NO-OP
+        debugCache("purgeCacheByTags", "No cache zone ID or API token provided. Skipping cache purge.");
+        return "missing-credentials";
+    }
+    try {
+        const response = await fetch(`https://api.cloudflare.com/client/v4/zones/${env.CACHE_PURGE_ZONE_ID}/purge_cache`, {
+            headers: {
+                Authorization: `Bearer ${env.CACHE_PURGE_API_TOKEN}`,
+                "Content-Type": "application/json",
+            },
+            method: "POST",
+            body: JSON.stringify({
+                tags,
+            }),
+        });
+        if (response.status === 429) {
+            // Rate limit exceeded
+            debugCache("purgeCacheByTags", "Rate limit exceeded. Skipping cache purge.");
+            return "rate-limit-exceeded";
+        }
+        const bodyResponse = (await response.json());
+        if (!bodyResponse.success) {
+            debugCache("purgeCacheByTags", "Cache purge failed. Errors:", bodyResponse.errors.map((error) => `${error.code}: ${error.message}`));
+            return "purge-failed";
+        }
+        debugCache("purgeCacheByTags", "Cache purged successfully for tags:", tags);
+        return "purge-success";
+    }
+    catch (error) {
+        console.error("Error purging cache by tags:", error);
+        return "purge-failed";
+    }
+}

package/dist/api/overrides/queue/do-queue.js

@@ -1,7 +1,7 @@
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
 export default {
-    name: "do-queue",
+    name: "durable-queue",
     send: async (msg) => {
         const durableObject = getCloudflareContext().env.NEXT_CACHE_DO_QUEUE;
         if (!durableObject)

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

@@ -0,0 +1,36 @@
+import type { Queue, QueueMessage } from "@opennextjs/aws/types/overrides";
+interface QueueCachingOptions {
+    /**
+     * The TTL for the regional cache in seconds.
+     * @default 5
+     */
+    regionalCacheTtlSec?: number;
+    /**
+     * Whether to wait for the queue ack before returning.
+     * When set to false, the cache will be populated asap and the queue will be called after.
+     * When set to true, the cache will be populated only after the queue ack is received.
+     * @default false
+     */
+    waitForQueueAck?: boolean;
+}
+declare class QueueCache implements Queue {
+    private originalQueue;
+    readonly name: string;
+    readonly regionalCacheTtlSec: number;
+    readonly waitForQueueAck: boolean;
+    cache: Cache | undefined;
+    localCache: Map<string, number>;
+    constructor(originalQueue: Queue, options: QueueCachingOptions);
+    send(msg: QueueMessage): Promise<void>;
+    private getCache;
+    private getCacheUrlString;
+    private getCacheKey;
+    private putToCache;
+    private isInCache;
+    /**
+     * Remove any value older than the TTL from the local cache
+     */
+    private clearLocalCache;
+}
+declare const _default: (originalQueue: Queue, opts?: QueueCachingOptions) => QueueCache;
+export default _default;

package/dist/api/overrides/queue/queue-cache.js

@@ -0,0 +1,93 @@
+import { error } from "@opennextjs/aws/adapters/logger.js";
+const DEFAULT_QUEUE_CACHE_TTL_SEC = 5;
+class QueueCache {
+    originalQueue;
+    name;
+    regionalCacheTtlSec;
+    waitForQueueAck;
+    cache;
+    // Local mapping from key to insertedAtSec
+    localCache = new Map();
+    constructor(originalQueue, options) {
+        this.originalQueue = originalQueue;
+        this.name = `cached-${originalQueue.name}`;
+        this.regionalCacheTtlSec = options.regionalCacheTtlSec ?? DEFAULT_QUEUE_CACHE_TTL_SEC;
+        this.waitForQueueAck = options.waitForQueueAck ?? false;
+    }
+    async send(msg) {
+        try {
+            const isCached = await this.isInCache(msg);
+            if (isCached) {
+                return;
+            }
+            if (!this.waitForQueueAck) {
+                await this.putToCache(msg);
+                await this.originalQueue.send(msg);
+            }
+            else {
+                await this.originalQueue.send(msg);
+                await this.putToCache(msg);
+            }
+        }
+        catch (e) {
+            error("Error sending message to queue", e);
+        }
+        finally {
+            this.clearLocalCache();
+        }
+    }
+    async getCache() {
+        if (!this.cache) {
+            this.cache = await caches.open("durable-queue");
+        }
+        return this.cache;
+    }
+    getCacheUrlString(msg) {
+        return `queue/${msg.MessageGroupId}/${msg.MessageDeduplicationId}`;
+    }
+    getCacheKey(msg) {
+        return "http://local.cache" + this.getCacheUrlString(msg);
+    }
+    async putToCache(msg) {
+        this.localCache.set(this.getCacheUrlString(msg), Date.now());
+        const cacheKey = this.getCacheKey(msg);
+        const cache = await this.getCache();
+        await cache.put(cacheKey, new Response(null, {
+            status: 200,
+            headers: {
+                "Cache-Control": `max-age=${this.regionalCacheTtlSec}`,
+                // Tag cache is set to the value of the soft tag assigned by Next.js
+                // This way you can invalidate this cache as well as any other regional cache
+                "Cache-Tag": `_N_T_/${msg.MessageBody.url}`,
+            },
+        }));
+    }
+    async isInCache(msg) {
+        if (this.localCache.has(this.getCacheUrlString(msg))) {
+            const insertedAt = this.localCache.get(this.getCacheUrlString(msg));
+            if (Date.now() - insertedAt < this.regionalCacheTtlSec * 1000) {
+                return true;
+            }
+            this.localCache.delete(this.getCacheUrlString(msg));
+            return false;
+        }
+        const cacheKey = this.getCacheKey(msg);
+        const cache = await this.getCache();
+        const cachedResponse = await cache.match(cacheKey);
+        if (cachedResponse) {
+            return true;
+        }
+    }
+    /**
+     * Remove any value older than the TTL from the local cache
+     */
+    clearLocalCache() {
+        const insertAtSecMax = Date.now() - this.regionalCacheTtlSec * 1000;
+        for (const [key, insertAtSec] of this.localCache.entries()) {
+            if (insertAtSec < insertAtSecMax) {
+                this.localCache.delete(key);
+            }
+        }
+    }
+}
+export default (originalQueue, opts = {}) => new QueueCache(originalQueue, opts);

package/dist/api/overrides/queue/queue-cache.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/overrides/queue/queue-cache.spec.js

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import queueCache from "./queue-cache";
+const mockedQueue = {
+    name: "mocked-queue",
+    send: vi.fn(),
+};
+const generateMessage = () => ({
+    MessageGroupId: "test",
+    MessageBody: {
+        eTag: "test",
+        url: "test",
+        host: "test",
+        lastModified: Date.now(),
+    },
+    MessageDeduplicationId: "test",
+});
+const mockedPut = vi.fn();
+const mockedMatch = vi.fn().mockReturnValue(null);
+describe("queue-cache", () => {
+    beforeEach(() => {
+        // @ts-ignore
+        globalThis.caches = {
+            open: vi.fn().mockReturnValue({
+                put: mockedPut,
+                match: mockedMatch,
+            }),
+        };
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    test("should send the message to the original queue", async () => {
+        const msg = generateMessage();
+        const queue = queueCache(mockedQueue, {});
+        expect(queue.name).toBe("cached-mocked-queue");
+        await queue.send(msg);
+        expect(mockedQueue.send).toHaveBeenCalledWith(msg);
+    });
+    test("should use the local cache", async () => {
+        const msg = generateMessage();
+        const queue = queueCache(mockedQueue, {});
+        await queue.send(msg);
+        expect(queue.localCache.size).toBe(1);
+        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
+        expect(mockedPut).toHaveBeenCalled();
+        const spiedHas = vi.spyOn(queue.localCache, "has");
+        await queue.send(msg);
+        expect(spiedHas).toHaveBeenCalled();
+        expect(mockedQueue.send).toHaveBeenCalledTimes(1);
+        expect(mockedMatch).toHaveBeenCalledTimes(1);
+    });
+    test("should clear the local cache after 5s", async () => {
+        vi.useFakeTimers();
+        const msg = generateMessage();
+        const queue = queueCache(mockedQueue, {});
+        await queue.send(msg);
+        expect(queue.localCache.size).toBe(1);
+        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
+        vi.advanceTimersByTime(5001);
+        const alteredMsg = generateMessage();
+        alteredMsg.MessageGroupId = "test2";
+        await queue.send(alteredMsg);
+        expect(queue.localCache.size).toBe(1);
+        console.log(queue.localCache);
+        expect(queue.localCache.has(`queue/test2/test`)).toBe(true);
+        expect(queue.localCache.has(`queue/test/test`)).toBe(false);
+        vi.useRealTimers();
+    });
+    test("should use the regional cache if not in local cache", async () => {
+        const msg = generateMessage();
+        const queue = queueCache(mockedQueue, {});
+        await queue.send(msg);
+        expect(mockedMatch).toHaveBeenCalledTimes(1);
+        expect(mockedPut).toHaveBeenCalledTimes(1);
+        expect(queue.localCache.size).toBe(1);
+        expect(queue.localCache.has(`queue/test/test`)).toBe(true);
+        // We need to delete the local cache to test the regional cache
+        queue.localCache.delete(`queue/test/test`);
+        const spiedHas = vi.spyOn(queue.localCache, "has");
+        await queue.send(msg);
+        expect(spiedHas).toHaveBeenCalled();
+        expect(mockedMatch).toHaveBeenCalledTimes(2);
+    });
+    test("should return early if the message is in the regional cache", async () => {
+        const msg = generateMessage();
+        const queue = queueCache(mockedQueue, {});
+        mockedMatch.mockReturnValueOnce(new Response(null, { status: 200 }));
+        const spiedSend = mockedQueue.send;
+        await queue.send(msg);
+        expect(spiedSend).not.toHaveBeenCalled();
+    });
+});

package/dist/api/overrides/tag-cache/d1-next-tag-cache.js

@@ -1,6 +1,6 @@
 import { error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
-import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
+import { debugCache, FALLBACK_BUILD_ID, purgeCacheByTags } from "../internal.js";
 export const NAME = "d1-next-mode-tag-cache";
 export const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export class D1NextModeTagCache {
@@ -52,6 +52,7 @@ export class D1NextModeTagCache {
         await db.batch(tags.map((tag) => db
             .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
             .bind(this.getCacheKey(tag), Date.now())));
+        await purgeCacheByTags(tags);
     }
     getConfig() {
         const db = getCloudflareContext().env[BINDING_NAME];

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -2,6 +2,9 @@ import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
 export declare const DEFAULT_WRITE_RETRIES = 3;
 export declare const DEFAULT_NUM_SHARDS = 4;
 export declare const NAME = "do-sharded-tag-cache";
+export declare const DEFAULT_REGION: "enam";
+export declare const AVAILABLE_REGIONS: readonly ["enam", "weur", "apac", "sam", "afr", "oc"];
+type AllowedDurableObjectRegion = (typeof AVAILABLE_REGIONS)[number];
 interface ShardedDOTagCacheOptions {
     /**
      * The number of shards that will be used.
@@ -49,6 +52,18 @@ interface ShardedDOTagCacheOptions {
     shardReplication?: {
         numberOfSoftReplicas: number;
         numberOfHardReplicas: number;
+        /**
+         * Enable regional replication for the shards.
+         *
+         * If not set, no regional replication will be performed and durable objects will be created without a location hint
+         *
+         * Can be used to reduce latency for users in different regions and to spread the load across multiple regions.
+         *
+         * This will increase the number of durable objects created, as each shard will be replicated in all regions.
+         */
+        regionalReplication?: {
+            defaultRegion: AllowedDurableObjectRegion;
+        };
     };
     /**
      * The number of retries to perform when writing tags
@@ -62,11 +77,13 @@ interface DOIdOptions {
     numberOfReplicas: number;
     shardType: "soft" | "hard";
     replicaId?: number;
+    region?: DurableObjectLocationHint;
 }
 export declare class DOId {
     options: DOIdOptions;
     shardId: string;
     replicaId: number;
+    region?: DurableObjectLocationHint;
     constructor(options: DOIdOptions);
     private generateRandomNumberBetween;
     get key(): string;
@@ -83,6 +100,8 @@ declare class ShardedDOTagCache implements NextModeTagCache {
     readonly numSoftReplicas: number;
     readonly numHardReplicas: number;
     readonly maxWriteRetries: number;
+    readonly enableRegionalReplication: boolean;
+    readonly defaultRegion: AllowedDurableObjectRegion;
     localCache?: Cache;
     constructor(opts?: ShardedDOTagCacheOptions);
     private getDurableObjectStub;
@@ -94,6 +113,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns An array of TagCacheDOId and tag
      */
     private generateDOIdArray;
+    getClosestRegion(): "enam" | "sam" | "weur" | "apac" | "oc" | "afr";
     /**
      * Same tags are guaranteed to be in the same shard
      * @param tags

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -2,26 +2,30 @@ import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
-import { debugCache } from "../internal";
+import { debugCache, purgeCacheByTags } from "../internal";
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
 export const NAME = "do-sharded-tag-cache";
 const SOFT_TAG_PREFIX = "_N_T_/";
+export const DEFAULT_REGION = "enam";
+export const AVAILABLE_REGIONS = ["enam", "weur", "apac", "sam", "afr", "oc"];
 export class DOId {
     options;
     shardId;
     replicaId;
+    region;
     constructor(options) {
         this.options = options;
-        const { baseShardId, shardType, numberOfReplicas, replicaId } = options;
+        const { baseShardId, shardType, numberOfReplicas, replicaId, region } = options;
         this.shardId = `tag-${shardType};${baseShardId}`;
         this.replicaId = replicaId ?? this.generateRandomNumberBetween(1, numberOfReplicas);
+        this.region = region;
     }
     generateRandomNumberBetween(min, max) {
         return Math.floor(Math.random() * (max - min + 1) + min);
     }
     get key() {
-        return `${this.shardId};replica-${this.replicaId}`;
+        return `${this.shardId};replica-${this.replicaId}${this.region ? `;region-${this.region}` : ""}`;
     }
 }
 class ShardedDOTagCache {
@@ -31,19 +35,27 @@ class ShardedDOTagCache {
     numSoftReplicas;
     numHardReplicas;
     maxWriteRetries;
+    enableRegionalReplication;
+    defaultRegion;
     localCache;
     constructor(opts = { baseShardSize: DEFAULT_NUM_SHARDS }) {
         this.opts = opts;
         this.numSoftReplicas = opts.shardReplication?.numberOfSoftReplicas ?? 1;
         this.numHardReplicas = opts.shardReplication?.numberOfHardReplicas ?? 1;
         this.maxWriteRetries = opts.maxWriteRetries ?? DEFAULT_WRITE_RETRIES;
+        this.enableRegionalReplication = Boolean(opts.shardReplication?.regionalReplication);
+        this.defaultRegion = opts.shardReplication?.regionalReplication?.defaultRegion ?? DEFAULT_REGION;
     }
     getDurableObjectStub(doId) {
         const durableObject = getCloudflareContext().env.NEXT_TAG_CACHE_DO_SHARDED;
         if (!durableObject)
             throw new IgnorableError("No durable object binding for cache revalidation");
         const id = durableObject.idFromName(doId.key);
-        return durableObject.get(id);
+        debug("[shardedTagCache] - Accessing Durable Object : ", {
+            key: doId.key,
+            region: doId.region,
+        });
+        return durableObject.get(id, { locationHint: doId.region });
     }
     /**
      * Generates a list of DO ids for the shards and replicas
@@ -55,9 +67,14 @@ class ShardedDOTagCache {
     generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
         let replicaIndexes = [1];
         const isSoft = shardType === "soft";
-        const numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
-        replicaIndexes = generateAllReplicas ? Array.from({ length: numReplicas }, (_, i) => i + 1) : [undefined];
-        return replicaIndexes.flatMap((replicaId) => {
+        let numReplicas = 1;
+        if (this.opts.shardReplication) {
+            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
+            replicaIndexes = generateAllReplicas
+                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
+                : [undefined];
+        }
+        const regionalReplicas = replicaIndexes.flatMap((replicaId) => {
             return tags
                 .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
                 .map((tag) => {
@@ -72,6 +89,51 @@ class ShardedDOTagCache {
                 };
             });
         });
+        if (!this.enableRegionalReplication)
+            return regionalReplicas;
+        // If we have regional replication enabled, we need to further duplicate the shards in all the regions
+        const regionalReplicasInAllRegions = generateAllReplicas
+            ? regionalReplicas.flatMap(({ doId, tag }) => {
+                return AVAILABLE_REGIONS.map((region) => {
+                    return {
+                        doId: new DOId({
+                            baseShardId: doId.options.baseShardId,
+                            numberOfReplicas: numReplicas,
+                            shardType,
+                            replicaId: doId.replicaId,
+                            region,
+                        }),
+                        tag,
+                    };
+                });
+            })
+            : regionalReplicas.map(({ doId, tag }) => {
+                doId.region = this.getClosestRegion();
+                return { doId, tag };
+            });
+        return regionalReplicasInAllRegions;
+    }
+    getClosestRegion() {
+        const continent = getCloudflareContext().cf?.continent;
+        if (!continent)
+            return this.defaultRegion;
+        debug("[shardedTagCache] - Continent : ", continent);
+        switch (continent) {
+            case "AF":
+                return "afr";
+            case "AS":
+                return "apac";
+            case "EU":
+                return "weur";
+            case "NA":
+                return "enam";
+            case "OC":
+                return "oc";
+            case "SA":
+                return "sam";
+            default:
+                return this.defaultRegion;
+        }
     }
     /**
      * Same tags are guaranteed to be in the same shard
@@ -196,6 +258,7 @@ class ShardedDOTagCache {
         await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
             await this.performWriteTagsWithRetry(doId, tags, currentTime);
         }));
+        await purgeCacheByTags(tags);
     }
     async performWriteTagsWithRetry(doId, tags, lastModified, retryNumber = 0) {
         try {

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.spec.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import shardedDOTagCache, { DOId } from "./do-sharded-tag-cache";
+import shardedDOTagCache, { AVAILABLE_REGIONS, DOId } from "./do-sharded-tag-cache";
 const hasBeenRevalidatedMock = vi.fn();
 const writeTagsMock = vi.fn();
 const idFromNameMock = vi.fn();
@@ -7,6 +7,8 @@ const getMock = vi
     .fn()
     .mockReturnValue({ hasBeenRevalidated: hasBeenRevalidatedMock, writeTags: writeTagsMock });
 const waitUntilMock = vi.fn().mockImplementation(async (fn) => fn());
+// @ts-expect-error - We define it here only for the test
+globalThis.continent = undefined;
 const sendDLQMock = vi.fn();
 vi.mock("../../cloudflare-context", () => ({
     getCloudflareContext: () => ({
@@ -17,6 +19,10 @@ vi.mock("../../cloudflare-context", () => ({
             },
         },
         ctx: { waitUntil: waitUntilMock },
+        cf: {
+            // @ts-expect-error - We define it here only for the test
+            continent: globalThis.continent,
+        },
     }),
 }));
 describe("DOShardedTagCache", () => {
@@ -96,6 +102,80 @@ describe("DOShardedTagCache", () => {
                 expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
                 expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
             });
+            it("should generate one doIds, but in the default region", () => {
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: false,
+                });
+                expect(shardedTagCollection.length).toBe(2);
+                const firstDOId = shardedTagCollection[0]?.doId;
+                const secondDOId = shardedTagCollection[1]?.doId;
+                expect(firstDOId?.shardId).toBe("tag-soft;shard-3");
+                expect(firstDOId?.region).toBe("enam");
+                expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
+                expect(secondDOId?.region).toBe("enam");
+                // We still need to check if the last part is between the correct boundaries
+                expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
+                expect(firstDOId?.replicaId).toBeLessThanOrEqual(2);
+                expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
+                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
+            });
+            it("should generate one doIds, but in the correct region", () => {
+                // @ts-expect-error - We define it here only for the test
+                globalThis.continent = "EU";
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: false,
+                });
+                expect(shardedTagCollection.length).toBe(2);
+                expect(shardedTagCollection[0]?.doId.region).toBe("weur");
+                expect(shardedTagCollection[1]?.doId.region).toBe("weur");
+                //@ts-expect-error - We need to reset the global variable
+                globalThis.continent = undefined;
+            });
+            it("should generate all the appropriate replicas in all the regions with enableRegionalReplication", () => {
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: true,
+                });
+                // 6 regions times 4 shards replica
+                expect(shardedTagCollection.length).toBe(24);
+                shardedTagCollection.forEach(({ doId }) => {
+                    expect(AVAILABLE_REGIONS).toContain(doId.region);
+                    // It should end with the region
+                    expect(doId.key).toMatch(/tag-(soft|hard);shard-\d;replica-\d;region-(enam|weur|sam|afr|apac|oc)$/);
+                });
+            });
         });
     });
     describe("hasBeenRevalidated", () => {

package/dist/cli/build/open-next/compileDurableObjects.js

@@ -7,6 +7,7 @@ export function compileDurableObjects(buildOpts) {
     const entryPoints = [
         _require.resolve("@opennextjs/cloudflare/durable-objects/queue"),
         _require.resolve("@opennextjs/cloudflare/durable-objects/sharded-tag-cache"),
+        _require.resolve("@opennextjs/cloudflare/durable-objects/bucket-cache-purge"),
     ];
     const { outputDir } = buildOpts;
     const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");

package/dist/cli/templates/worker.d.ts

@@ -1,5 +1,6 @@
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
+export { BucketCachePurge } from "./.build/durable-objects/bucket-cache-purge.js";
 declare const _default: {
     fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: CloudflareEnv, ctx: ExecutionContext): Promise<any>;
 };

package/dist/cli/templates/worker.js

@@ -6,6 +6,8 @@ import { handler as middlewareHandler } from "./middleware/handler.mjs";
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 //@ts-expect-error: Will be resolved by wrangler build
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
+//@ts-expect-error: Will be resolved by wrangler build
+export { BucketCachePurge } from "./.build/durable-objects/bucket-cache-purge.js";
 export default {
     async fetch(request, env, ctx) {
         return runWithCloudflareRequestContext(request, env, ctx, async () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "^3.6.2",
+    "@opennextjs/aws": "3.6.4",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "ts-tqdm": "^0.8.6"