@opennextjs/cloudflare 1.8.5 → 1.9.1

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

@@ -14,6 +14,7 @@ declare global {
         NEXT_INC_CACHE_R2_BUCKET?: R2Bucket;
         [R2_CACHE_PREFIX_ENV_NAME]?: string;
         NEXT_TAG_CACHE_D1?: D1Database;
+        NEXT_TAG_CACHE_KV?: KVNamespace;
         NEXT_TAG_CACHE_DO_SHARDED?: DurableObjectNamespace<DOShardedTagCache>;
         NEXT_TAG_CACHE_DO_SHARDED_DLQ?: Queue;
         NEXT_CACHE_DO_QUEUE?: DurableObjectNamespace<DOQueueHandler>;

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

@@ -1,4 +1,5 @@
 import { DurableObject } from "cloudflare:workers";
+import { debugCache } from "../overrides/internal.js";
 export class DOShardedTagCache extends DurableObject {
     sql;
     constructor(state, env) {
@@ -13,10 +14,9 @@ export class DOShardedTagCache extends DurableObject {
             const result = this.sql
                 .exec(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`, ...tags)
                 .toArray();
-            if (result.length === 0)
-                return 0;
-            // We only care about the most recent revalidation
-            return result[0]?.time;
+            const timeMs = (result[0]?.time ?? 0);
+            debugCache("DOShardedTagCache", `getLastRevalidated tags=${tags} -> time=${timeMs}`);
+            return timeMs;
         }
         catch (e) {
             console.error(e);
@@ -25,11 +25,14 @@ export class DOShardedTagCache extends DurableObject {
         }
     }
     async hasBeenRevalidated(tags, lastModified) {
-        return (this.sql
+        const revalidated = this.sql
             .exec(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`, ...tags, lastModified ?? Date.now())
-            .toArray().length > 0);
+            .toArray().length > 0;
+        debugCache("DOShardedTagCache", `hasBeenRevalidated tags=${tags} -> revalidated=${revalidated}`);
+        return revalidated;
     }
     async writeTags(tags, lastModified) {
+        debugCache("DOShardedTagCache", `writeTags tags=${tags} time=${lastModified}`);
         tags.forEach((tag) => {
             this.sql.exec(`INSERT OR REPLACE INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`, tag, lastModified);
         });

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

@@ -21,7 +21,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Get ${key}`);
+        debugCache("KVIncrementalCache", `get ${key}`);
         try {
             const entry = await kv.get(this.getKVKey(key, cacheType), "json");
             if (!entry)
@@ -44,7 +44,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Set ${key}`);
+        debugCache("KVIncrementalCache", `set ${key}`);
         try {
             await kv.put(this.getKVKey(key, cacheType), JSON.stringify({
                 value,
@@ -64,7 +64,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Delete ${key}`);
+        debugCache("KVIncrementalCache", `delete ${key}`);
         try {
             // Only cache that gets deleted is the ISR/SSG cache.
             await kv.delete(this.getKVKey(key, "cache"));

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

@@ -18,7 +18,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Get ${key}`);
+        debugCache("R2IncrementalCache", `get ${key}`);
         try {
             const r2Object = await r2.get(this.getR2Key(key, cacheType));
             if (!r2Object)
@@ -37,7 +37,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Set ${key}`);
+        debugCache("R2IncrementalCache", `set ${key}`);
         try {
             await r2.put(this.getR2Key(key, cacheType), JSON.stringify(value));
         }
@@ -49,7 +49,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Delete ${key}`);
+        debugCache("R2IncrementalCache", `delete ${key}`);
         try {
             await r2.delete(this.getR2Key(key));
         }

package/dist/api/overrides/incremental-cache/regional-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, isPurgeCacheEnabled } from "../internal.js";
 import { NAME as KV_CACHE_NAME } from "./kv-incremental-cache.js";
 const ONE_MINUTE_IN_SECONDS = 60;
 const THIRTY_MINUTES_IN_SECONDS = ONE_MINUTE_IN_SECONDS * 30;
@@ -28,8 +28,7 @@ class RegionalCache {
             throw new Error("The KV incremental cache does not need a regional cache.");
         }
         this.name = this.store.name;
-        this.opts.shouldLazilyUpdateOnCacheHit ??=
-            this.opts.mode === "long-lived" && !this.#hasAutomaticCachePurging;
+        this.opts.shouldLazilyUpdateOnCacheHit ??= this.opts.mode === "long-lived" && !isPurgeCacheEnabled();
     }
     get #bypassTagCacheOnCacheHit() {
         if (this.opts.bypassTagCacheOnCacheHit !== undefined) {
@@ -37,12 +36,7 @@ class RegionalCache {
             return this.opts.bypassTagCacheOnCacheHit;
         }
         // Otherwise we default to whether the automatic cache purging is enabled or not
-        return this.#hasAutomaticCachePurging;
-    }
-    get #hasAutomaticCachePurging() {
-        // The `?` is required at `openNextConfig?` or the Open Next build fails because of a type error
-        const cdnInvalidation = globalThis.openNextConfig?.default?.override?.cdnInvalidation;
-        return cdnInvalidation !== undefined && cdnInvalidation !== "dummy";
+        return isPurgeCacheEnabled();
     }
     async get(key, cacheType) {
         try {
@@ -51,7 +45,7 @@ class RegionalCache {
             // Check for a cached entry as this will be faster than the store response.
             const cachedResponse = await cache.match(urlKey);
             if (cachedResponse) {
-                debugCache("Get - cached response");
+                debugCache("RegionalCache", `get ${key} -> cached response`);
                 // Re-fetch from the store and update the regional cache in the background.
                 // Note: this is only useful when the Cache API is not purged automatically.
                 if (this.opts.shouldLazilyUpdateOnCacheHit) {
@@ -72,6 +66,7 @@ class RegionalCache {
             const { value, lastModified } = rawEntry ?? {};
             if (!value || typeof lastModified !== "number")
                 return null;
+            debugCache("RegionalCache", `get ${key} -> put to cache`);
             // Update the locale cache after retrieving from the store.
             getCloudflareContext().ctx.waitUntil(this.putToCache({ key, cacheType, entry: { value, lastModified } }));
             return { value, lastModified };
@@ -83,6 +78,7 @@ class RegionalCache {
     }
     async set(key, value, cacheType) {
         try {
+            debugCache("RegionalCache", `set ${key}`);
             await this.store.set(key, value, cacheType);
             await this.putToCache({
                 key,
@@ -100,6 +96,7 @@ class RegionalCache {
         }
     }
     async delete(key) {
+        debugCache("RegionalCache", `delete ${key}`);
         try {
             await this.store.delete(key);
             const cache = await this.getCacheInstance();

package/dist/api/overrides/incremental-cache/static-assets-incremental-cache.d.ts

@@ -9,7 +9,7 @@ export declare const NAME = "cf-static-assets-incremental-cache";
 declare class StaticAssetsIncrementalCache implements IncrementalCache {
     readonly name = "cf-static-assets-incremental-cache";
     get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
-    set(): Promise<void>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, _value: CacheValue<CacheType>, cacheType?: CacheType): Promise<void>;
     delete(): Promise<void>;
     protected getAssetUrl(key: string, cacheType?: CacheEntryType): string;
 }

package/dist/api/overrides/incremental-cache/static-assets-incremental-cache.js

@@ -16,7 +16,7 @@ class StaticAssetsIncrementalCache {
         const assets = getCloudflareContext().env.ASSETS;
         if (!assets)
             throw new IgnorableError("No Static Assets");
-        debugCache(`Get ${key}`);
+        debugCache("StaticAssetsIncrementalCache", `get ${key}`);
         try {
             const response = await assets.fetch(this.getAssetUrl(key, cacheType));
             if (!response.ok) {
@@ -33,11 +33,11 @@ class StaticAssetsIncrementalCache {
             return null;
         }
     }
-    async set() {
-        error("Failed to set to read-only cache");
+    async set(key, _value, cacheType) {
+        error(`StaticAssetsIncrementalCache: Failed to set to read-only cache key=${key} type=${cacheType}`);
     }
     async delete() {
-        error("Failed to delete from read-only cache");
+        error("StaticAssetsIncrementalCache: Failed to delete from read-only cache");
     }
     getAssetUrl(key, cacheType) {
         if (cacheType === "composable") {

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

@@ -12,5 +12,6 @@ export type KeyOptions = {
     buildId: string | undefined;
 };
 export declare function computeCacheKey(key: string, options: KeyOptions): string;
+export declare function isPurgeCacheEnabled(): boolean;
 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

@@ -13,6 +13,11 @@ export function computeCacheKey(key, options) {
     const hash = createHash("sha256").update(key).digest("hex");
     return `${prefix}/${buildId}/${hash}.${cacheType}`.replace(/\/+/g, "/");
 }
+export function isPurgeCacheEnabled() {
+    // The `?` is required at `openNextConfig?` or the Open Next build fails because of a type error
+    const cdnInvalidation = globalThis.openNextConfig?.default?.override?.cdnInvalidation;
+    return cdnInvalidation !== undefined && cdnInvalidation !== "dummy";
+}
 export async function purgeCacheByTags(tags) {
     const { env } = getCloudflareContext();
     // We have a durable object for purging cache

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, purgeCacheByTags } from "../internal.js";
+import { debugCache, FALLBACK_BUILD_ID, isPurgeCacheEnabled, purgeCacheByTags } from "../internal.js";
 export const NAME = "d1-next-mode-tag-cache";
 export const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export class D1NextModeTagCache {
@@ -8,35 +8,38 @@ export class D1NextModeTagCache {
     name = NAME;
     async getLastRevalidated(tags) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return 0;
+        }
         try {
             const result = await db
                 .prepare(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`)
                 .bind(...tags.map((tag) => this.getCacheKey(tag)))
                 .run();
-            if (result.results.length === 0)
-                return 0;
-            // We only care about the most recent revalidation
-            return (result.results[0]?.time ?? 0);
+            const timeMs = (result.results[0]?.time ?? 0);
+            debugCache("D1NextModeTagCache", `getLastRevalidated tags=${tags} -> ${timeMs}`);
+            return timeMs;
         }
         catch (e) {
-            error(e);
             // By default we don't want to crash here, so we return false
             // We still log the error though so we can debug it
+            error(e);
             return 0;
         }
     }
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return false;
+        }
         try {
             const result = await db
                 .prepare(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`)
                 .bind(...tags.map((tag) => this.getCacheKey(tag)), lastModified ?? Date.now())
                 .raw();
-            return result.length > 0;
+            const revalidated = result.length > 0;
+            debugCache("D1NextModeTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> ${revalidated}`);
+            return revalidated;
         }
         catch (e) {
             error(e);
@@ -47,20 +50,23 @@ export class D1NextModeTagCache {
     }
     async writeTags(tags) {
         const { isDisabled, db } = this.getConfig();
-        // TODO: Remove `tags.length === 0` when https://github.com/opennextjs/opennextjs-aws/pull/828 is used
         if (isDisabled || tags.length === 0)
             return Promise.resolve();
+        const nowMs = Date.now();
         await db.batch(tags.map((tag) => db
             .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
-            .bind(this.getCacheKey(tag), Date.now())));
-        await purgeCacheByTags(tags);
+            .bind(this.getCacheKey(tag), nowMs)));
+        debugCache("D1NextModeTagCache", `writeTags tags=${tags} time=${nowMs}`);
+        // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
+        if (isPurgeCacheEnabled()) {
+            await purgeCacheByTags(tags);
+        }
     }
     getConfig() {
         const db = getCloudflareContext().env[BINDING_NAME];
         if (!db)
             debugCache("No D1 database found");
-        const isDisabled = !!globalThis.openNextConfig
-            .dangerous?.disableTagCache;
+        const isDisabled = Boolean(globalThis.openNextConfig.dangerous?.disableTagCache);
         return !db || isDisabled
             ? { isDisabled: true }
             : {

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

@@ -2,7 +2,7 @@ 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.js";
-import { debugCache, purgeCacheByTags } from "../internal.js";
+import { debugCache, isPurgeCacheEnabled, purgeCacheByTags } from "../internal.js";
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
 export const NAME = "do-sharded-tag-cache";
@@ -32,10 +32,9 @@ class ShardedDOTagCache {
      */
     async getLastRevalidated(tags) {
         const { isDisabled } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return 0;
-        if (tags.length === 0)
-            return 0; // No tags to check
+        }
         const deduplicatedTags = Array.from(new Set(tags)); // We deduplicate the tags to avoid unnecessary requests
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags: deduplicatedTags });
@@ -43,16 +42,19 @@ class ShardedDOTagCache {
                 const cachedValue = await this.getFromRegionalCache({ doId, tags });
                 // If all the value were found in the regional cache, we can just return the max value
                 if (cachedValue.length === tags.length) {
-                    return Math.max(...cachedValue.map((item) => item.time));
+                    const timeMs = Math.max(...cachedValue.map((item) => item.time));
+                    debugCache("ShardedDOTagCache", `getLastRevalidated tags=${tags} -> ${timeMs} (regional cache)`);
+                    return timeMs;
                 }
                 // Otherwise we need to check the durable object on the ones that were not found in the cache
                 const filteredTags = deduplicatedTags.filter((tag) => !cachedValue.some((item) => item.tag === tag));
                 const stub = this.getDurableObjectStub(doId);
                 const lastRevalidated = await stub.getLastRevalidated(filteredTags);
-                const result = Math.max(...cachedValue.map((item) => item.time), lastRevalidated);
+                const timeMs = Math.max(...cachedValue.map((item) => item.time), lastRevalidated);
                 // We then need to populate the regional cache with the missing tags
                 getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags }, stub));
-                return result;
+                debugCache("ShardedDOTagCache", `getLastRevalidated tags=${tags} -> ${timeMs}`);
+                return timeMs;
             }));
             return Math.max(...shardedTagRevalidationOutcomes);
         }
@@ -70,8 +72,9 @@ class ShardedDOTagCache {
      */
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return false;
+        }
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
@@ -81,6 +84,7 @@ class ShardedDOTagCache {
                     return (cachedValue.time ?? 0) > (lastModified ?? Date.now());
                 });
                 if (cacheHasBeenRevalidated) {
+                    debugCache("ShardedDOTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> true (regional cache)`);
                     return true;
                 }
                 const stub = this.getDurableObjectStub(doId);
@@ -90,6 +94,7 @@ class ShardedDOTagCache {
                     // We need to put the missing tags in the regional cache
                     getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags: remainingTags }, stub));
                 }
+                debugCache("ShardedDOTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> ${_hasBeenRevalidated}`);
                 return _hasBeenRevalidated;
             }));
             return shardedTagRevalidationOutcomes.some((result) => result);
@@ -109,13 +114,17 @@ class ShardedDOTagCache {
         const { isDisabled } = this.getConfig();
         if (isDisabled)
             return;
-        const shardedTagGroups = this.groupTagsByDO({ tags, generateAllReplicas: true });
         // We want to use the same revalidation time for all tags
-        const currentTime = Date.now();
+        const nowMs = Date.now();
+        debugCache("ShardedDOTagCache", `writeTags tags=${tags} time=${nowMs}`);
+        const shardedTagGroups = this.groupTagsByDO({ tags, generateAllReplicas: true });
         await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-            await this.performWriteTagsWithRetry(doId, tags, currentTime);
+            await this.performWriteTagsWithRetry(doId, tags, nowMs);
         }));
-        await purgeCacheByTags(tags);
+        // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
+        if (isPurgeCacheEnabled()) {
+            await purgeCacheByTags(tags);
+        }
     }
     /**
      * The following methods are public only because they are accessed from the tests

package/dist/api/overrides/tag-cache/kv-next-tag-cache.d.ts

@@ -0,0 +1,33 @@
+import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
+export declare const NAME = "kv-next-mode-tag-cache";
+export declare const BINDING_NAME = "NEXT_TAG_CACHE_KV";
+/**
+ * Tag Cache based on a KV namespace
+ *
+ * Warning:
+ * This implementation is considered experimental for now.
+ * KV is eventually consistent and can take up to 60s to reflect the last write.
+ * This means that:
+ * - revalidations can take up to 60s to apply
+ * - when a page depends on multiple tags they can be inconsistent for up to 60s.
+ *   It also means that cached data could be outdated for one tag when other tags
+ *   are revalidated resulting in the page being generated based on outdated data.
+ */
+export declare class KVNextModeTagCache implements NextModeTagCache {
+    #private;
+    readonly mode: "nextMode";
+    readonly name = "kv-next-mode-tag-cache";
+    getLastRevalidated(tags: string[]): Promise<number>;
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    writeTags(tags: string[]): Promise<void>;
+    /**
+     * Returns the KV namespace when it exists and tag cache is not disabled.
+     *
+     * @returns KV namespace or undefined
+     */
+    private getKv;
+    protected getCacheKey(key: string): string;
+    protected getBuildId(): string;
+}
+declare const _default: KVNextModeTagCache;
+export default _default;

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

@@ -0,0 +1,91 @@
+import { error } from "@opennextjs/aws/adapters/logger.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID, isPurgeCacheEnabled, purgeCacheByTags } from "../internal.js";
+export const NAME = "kv-next-mode-tag-cache";
+export const BINDING_NAME = "NEXT_TAG_CACHE_KV";
+/**
+ * Tag Cache based on a KV namespace
+ *
+ * Warning:
+ * This implementation is considered experimental for now.
+ * KV is eventually consistent and can take up to 60s to reflect the last write.
+ * This means that:
+ * - revalidations can take up to 60s to apply
+ * - when a page depends on multiple tags they can be inconsistent for up to 60s.
+ *   It also means that cached data could be outdated for one tag when other tags
+ *   are revalidated resulting in the page being generated based on outdated data.
+ */
+export class KVNextModeTagCache {
+    mode = "nextMode";
+    name = NAME;
+    async getLastRevalidated(tags) {
+        const timeMs = await this.#getLastRevalidated(tags);
+        debugCache("KVNextModeTagCache", `getLastRevalidated tags=${tags} -> time=${timeMs}`);
+        return timeMs;
+    }
+    /**
+     * Implementation of `getLastRevalidated`.
+     *
+     * This implementation is separated so that `hasBeenRevalidated` do not include logs from `getLastRevalidated`.
+     */
+    async #getLastRevalidated(tags) {
+        const kv = this.getKv();
+        if (!kv || tags.length === 0) {
+            return 0;
+        }
+        try {
+            const keys = tags.map((tag) => this.getCacheKey(tag));
+            // Use the `json` type to get back numbers/null
+            const result = await kv.get(keys, { type: "json" });
+            const revalidations = [...result.values()].filter((v) => v != null);
+            return revalidations.length === 0 ? 0 : Math.max(...revalidations);
+        }
+        catch (e) {
+            // By default we don't want to crash here, so we return false
+            // We still log the error though so we can debug it
+            error(e);
+            return 0;
+        }
+    }
+    async hasBeenRevalidated(tags, lastModified) {
+        const revalidated = (await this.#getLastRevalidated(tags)) > (lastModified ?? Date.now());
+        debugCache("KVNextModeTagCache", `hasBeenRevalidated tags=${tags} lastModified=${lastModified} -> ${revalidated}`);
+        return revalidated;
+    }
+    async writeTags(tags) {
+        const kv = this.getKv();
+        if (!kv || tags.length === 0) {
+            return Promise.resolve();
+        }
+        const nowMs = Date.now();
+        await Promise.all(tags.map(async (tag) => {
+            await kv.put(this.getCacheKey(tag), String(nowMs));
+        }));
+        debugCache("KVNextModeTagCache", `writeTags tags=${tags} time=${nowMs}`);
+        // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
+        if (isPurgeCacheEnabled()) {
+            await purgeCacheByTags(tags);
+        }
+    }
+    /**
+     * Returns the KV namespace when it exists and tag cache is not disabled.
+     *
+     * @returns KV namespace or undefined
+     */
+    getKv() {
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv) {
+            error(`No KV binding ${BINDING_NAME} found`);
+            return undefined;
+        }
+        const isDisabled = Boolean(globalThis.openNextConfig.dangerous?.disableTagCache);
+        return isDisabled ? undefined : kv;
+    }
+    getCacheKey(key) {
+        return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
+    }
+    getBuildId() {
+        return process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+    }
+}
+export default new KVNextModeTagCache();

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

@@ -2,6 +2,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>;
+    fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: CloudflareEnv, ctx: ExecutionContext<unknown>): Promise<any>;
 };
 export default _default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.8.5",
+  "version": "1.9.1",
   "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.7.7",
+    "@opennextjs/aws": "3.8.0",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
@@ -51,7 +51,7 @@
     "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250224.0",
+    "@cloudflare/workers-types": "^4.20250917.0",
     "@eslint/js": "^9.11.1",
     "@tsconfig/strictest": "^2.0.5",
     "@types/mock-fs": "^4.13.4",