@opennextjs/cloudflare 1.0.4 → 1.2.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 { BaseOverride, LazyLoadedOverride, OpenNextConfig as AwsOpenNextConfig, type RoutePreloadingBehavior } from "@opennextjs/aws/types/open-next";
+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,12 +20,22 @@ 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
      * @default false
      */
     enableCacheInterception?: boolean;
+    /**
+     * Route preloading behavior.
+     * Using a value other than "none" can result in higher CPU usage on cold starts.
+     * @default "none"
+     */
+    routePreloadingBehavior?: RoutePreloadingBehavior;
 };
 /**
  * Defines the OpenNext configuration that targets the Cloudflare adapter

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, routePreloadingBehavior = "none", } = config;
     return {
         default: {
             override: {
@@ -15,8 +15,9 @@ export function defineCloudflareConfig(config = {}) {
                 incrementalCache: resolveIncrementalCache(incrementalCache),
                 tagCache: resolveTagCache(tagCache),
                 queue: resolveQueue(queue),
+                cdnInvalidation: resolveCdnInvalidation(cachePurge),
             },
-            routePreloadingBehavior: "withWaitUntil",
+            routePreloadingBehavior,
         },
         // node:crypto is used to compute cache keys
         edgeExternals: ["node:crypto"],
@@ -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.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];