@opennextjs/cloudflare 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/api/config.js

@@ -17,6 +17,8 @@ export function defineCloudflareConfig(config = {}) {
                 queue: resolveQueue(queue),
             },
         },
+        // node:crypto is used to compute cache keys
+        edgeExternals: ["node:crypto"],
     };
 }
 function resolveIncrementalCache(value = "dummy") {

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

@@ -1,9 +1,13 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
-export declare const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
-export declare const STATUS_DELETED = 1;
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "cf-kv-incremental-cache";
+export declare const BINDING_NAME = "NEXT_INC_CACHE_KV";
+export type KeyOptions = {
+    isFetch?: boolean;
+    buildId?: string;
+};
+export declare function computeCacheKey(key: string, options: KeyOptions): string;
 /**
- * Open Next cache based on cloudflare KV and Assets.
+ * Open Next cache based on Cloudflare KV.
  *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
@@ -15,9 +19,6 @@ declare class KVIncrementalCache implements IncrementalCache {
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
     protected getKVKey(key: string, isFetch?: boolean): string;
-    protected getAssetUrl(key: string, isFetch?: boolean): string;
-    protected debug(...args: unknown[]): void;
-    protected getBuildId(): string;
 }
 declare const _default: KVIncrementalCache;
 export default _default;

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

@@ -1,10 +1,17 @@
-import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { createHash } from "node:crypto";
+import { error } from "@opennextjs/aws/adapters/logger.js";
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
-export const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
-export const STATUS_DELETED = 1;
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "cf-kv-incremental-cache";
+export const BINDING_NAME = "NEXT_INC_CACHE_KV";
+export function computeCacheKey(key, options) {
+    const { isFetch = false, buildId = FALLBACK_BUILD_ID } = options;
+    const hash = createHash("sha256").update(key).digest("hex");
+    return `${buildId}/${hash}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+}
 /**
- * Open Next cache based on cloudflare KV and Assets.
+ * Open Next cache based on Cloudflare KV.
  *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
@@ -13,112 +20,65 @@ export const NAME = "cf-kv-incremental-cache";
 class KVIncrementalCache {
     name = NAME;
     async get(key, isFetch) {
-        const cfEnv = getCloudflareContext().env;
-        const kv = cfEnv.NEXT_INC_CACHE_KV;
-        const assets = cfEnv.ASSETS;
-        if (!(kv || assets)) {
-            throw new IgnorableError(`No KVNamespace nor Fetcher`);
-        }
-        this.debug(`Get ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Get ${key}`);
         try {
-            let entry = null;
-            if (kv) {
-                this.debug(`- From KV`);
-                const kvKey = this.getKVKey(key, isFetch);
-                entry = await kv.get(kvKey, "json");
-                if (entry?.status === STATUS_DELETED) {
-                    return null;
-                }
-            }
-            if (!entry && assets) {
-                this.debug(`- From Assets`);
-                const url = this.getAssetUrl(key, isFetch);
-                const response = await assets.fetch(url);
-                if (response.ok) {
-                    // TODO: consider populating KV with the asset value if faster.
-                    // This could be optional as KV writes are $$.
-                    // See https://github.com/opennextjs/opennextjs-cloudflare/pull/194#discussion_r1893166026
-                    entry = {
-                        value: await response.json(),
-                        // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
-                        lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
-                    };
-                }
-                if (!kv) {
-                    // The cache can not be updated when there is no KV
-                    // As we don't want to keep serving stale data for ever,
-                    // we pretend the entry is not in cache
-                    if (entry?.value &&
-                        "kind" in entry.value &&
-                        entry.value.kind === "FETCH" &&
-                        entry.value.data?.headers?.expires) {
-                        const expiresTime = new Date(entry.value.data.headers.expires).getTime();
-                        if (!isNaN(expiresTime) && expiresTime <= Date.now()) {
-                            this.debug(`found expired entry (expire time: ${entry.value.data.headers.expires})`);
-                            return null;
-                        }
-                    }
-                }
+            const entry = await kv.get(this.getKVKey(key, isFetch), "json");
+            if (!entry)
+                return null;
+            if ("lastModified" in entry) {
+                return entry;
             }
-            this.debug(entry ? `-> hit` : `-> miss`);
-            return { value: entry?.value, lastModified: entry?.lastModified };
+            // if there is no lastModified property, the file was stored during build-time cache population.
+            return {
+                value: entry,
+                lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+            };
         }
-        catch {
-            throw new RecoverableError(`Failed to get cache [${key}]`);
+        catch (e) {
+            error("Failed to get from cache", e);
+            return null;
         }
     }
     async set(key, value, isFetch) {
-        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Set ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Set ${key}`);
         try {
-            const kvKey = this.getKVKey(key, isFetch);
-            // Note: We can not set a TTL as we might fallback to assets,
-            //       still removing old data (old BUILD_ID) could help avoiding
-            //       the cache growing too big.
-            await kv.put(kvKey, JSON.stringify({
+            await kv.put(this.getKVKey(key, isFetch), JSON.stringify({
                 value,
                 // Note: `Date.now()` returns the time of the last IO rather than the actual time.
                 //       See https://developers.cloudflare.com/workers/reference/security-model/
                 lastModified: Date.now(),
-            }));
+            })
+            // TODO: Figure out how to best leverage KV's TTL.
+            // NOTE: Ideally, the cache should operate in an SWR-like manner.
+            );
         }
-        catch {
-            throw new RecoverableError(`Failed to set cache [${key}]`);
+        catch (e) {
+            error("Failed to set to cache", e);
         }
     }
     async delete(key) {
-        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Delete ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Delete ${key}`);
         try {
-            const kvKey = this.getKVKey(key, /* isFetch= */ false);
-            // Do not delete the key as we would then fallback to the assets.
-            await kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
+            await kv.delete(this.getKVKey(key, /* isFetch= */ false));
         }
-        catch {
-            throw new RecoverableError(`Failed to delete cache [${key}]`);
+        catch (e) {
+            error("Failed to delete from cache", e);
         }
     }
     getKVKey(key, isFetch) {
-        return `${this.getBuildId()}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
-    }
-    getAssetUrl(key, isFetch) {
-        return isFetch
-            ? `http://assets.local/${CACHE_ASSET_DIR}/__fetch/${this.getBuildId()}/${key}`
-            : `http://assets.local/${CACHE_ASSET_DIR}/${this.getBuildId()}/${key}.cache`;
-    }
-    debug(...args) {
-        if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
-            console.log(`[Cache ${this.name}] `, ...args);
-        }
-    }
-    getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+        return computeCacheKey(key, {
+            buildId: process.env.NEXT_BUILD_ID,
+            isFetch,
+        });
     }
 }
 export default new KVIncrementalCache();

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

@@ -1,5 +1,14 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "cf-r2-incremental-cache";
+export declare const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
+export declare const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
+export declare const DEFAULT_PREFIX = "incremental-cache";
+export type KeyOptions = {
+    isFetch?: boolean;
+    directory?: string;
+    buildId?: string;
+};
+export declare function computeCacheKey(key: string, options: KeyOptions): string;
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.

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

@@ -1,7 +1,17 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { createHash } from "node:crypto";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "cf-r2-incremental-cache";
+export const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
+export const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
+export const DEFAULT_PREFIX = "incremental-cache";
+export function computeCacheKey(key, options) {
+    const { isFetch = false, directory = DEFAULT_PREFIX, buildId = FALLBACK_BUILD_ID } = options;
+    const hash = createHash("sha256").update(key).digest("hex");
+    return `${directory}/${buildId}/${hash}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+}
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -12,10 +22,10 @@ export const NAME = "cf-r2-incremental-cache";
 class R2IncrementalCache {
     name = NAME;
     async get(key, isFetch) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Get ${key}`);
+        debugCache(`Get ${key}`);
         try {
             const r2Object = await r2.get(this.getR2Key(key, isFetch));
             if (!r2Object)
@@ -31,10 +41,10 @@ class R2IncrementalCache {
         }
     }
     async set(key, value, isFetch) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Set ${key}`);
+        debugCache(`Set ${key}`);
         try {
             await r2.put(this.getR2Key(key, isFetch), JSON.stringify(value));
         }
@@ -43,10 +53,10 @@ class R2IncrementalCache {
         }
     }
     async delete(key) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Delete ${key}`);
+        debugCache(`Delete ${key}`);
         try {
             await r2.delete(this.getR2Key(key));
         }
@@ -55,8 +65,11 @@ class R2IncrementalCache {
         }
     }
     getR2Key(key, isFetch) {
-        const directory = getCloudflareContext().env.NEXT_INC_CACHE_R2_PREFIX ?? "incremental-cache";
-        return `${directory}/${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
+        return computeCacheKey(key, {
+            directory: getCloudflareContext().env[PREFIX_ENV_NAME],
+            buildId: process.env.NEXT_BUILD_ID,
+            isFetch,
+        });
     }
 }
 export default new R2IncrementalCache();

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

@@ -1,5 +1,5 @@
 import { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
-import { IncrementalCacheEntry } from "./internal.js";
+import { IncrementalCacheEntry } from "../internal.js";
 type Options = {
     /**
      * The mode to use for the regional cache.
@@ -9,6 +9,13 @@ type Options = {
      *                 or an ISR/SSG entry for up to 30 minutes.
      */
     mode: "short-lived" | "long-lived";
+    /**
+     * The default TTL of long-lived cache entries.
+     * When no revalidate is provided, the default age will be used.
+     *
+     * @default `THIRTY_MINUTES_IN_SECONDS`
+     */
+    defaultLongLivedTtlSec?: number;
     /**
      * Whether the regional cache entry should be updated in the background or not when it experiences
      * a cache hit.
@@ -17,6 +24,11 @@ type Options = {
      */
     shouldLazilyUpdateOnCacheHit?: boolean;
 };
+interface PutToCacheInput {
+    key: string;
+    isFetch: boolean | undefined;
+    entry: IncrementalCacheEntry<boolean>;
+}
 /**
  * Wrapper adding a regional cache on an `IncrementalCache` implementation
  */
@@ -30,8 +42,8 @@ declare class RegionalCache implements IncrementalCache {
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
     protected getCacheInstance(): Promise<Cache>;
-    protected getCacheKey(key: string, isFetch?: boolean): Request<unknown, CfProperties<unknown>>;
-    protected putToCache(key: Request, entry: IncrementalCacheEntry<boolean>): Promise<void>;
+    protected getCacheUrlKey(key: string, isFetch?: boolean): string;
+    protected putToCache({ key, isFetch, entry }: PutToCacheInput): Promise<void>;
 }
 /**
  * A regional cache will wrap an incremental cache and provide faster cache lookups for an entry
@@ -50,6 +62,9 @@ declare class RegionalCache implements IncrementalCache {
  *                                  or an ISR/SSG entry for up to 30 minutes.
  * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
  *                                          the background or not when it experiences a cache hit.
+ * @param opts.defaultLongLivedTtlSec The default age to use for long-lived cache entries.
+ *                                  When no revalidate is provided, the default age will be used.
+ *                                  @default `THIRTY_MINUTES_IN_SECONDS`
  *
  * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */

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

@@ -1,5 +1,6 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } 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;
@@ -23,17 +24,17 @@ class RegionalCache {
     async get(key, isFetch) {
         try {
             const cache = await this.getCacheInstance();
-            const localCacheKey = this.getCacheKey(key, isFetch);
+            const urlKey = this.getCacheUrlKey(key, isFetch);
             // Check for a cached entry as this will be faster than the store response.
-            const cachedResponse = await cache.match(localCacheKey);
+            const cachedResponse = await cache.match(urlKey);
             if (cachedResponse) {
-                debug("Get - cached response");
+                debugCache("Get - cached response");
                 // Re-fetch from the store and update the regional cache in the background
                 if (this.opts.shouldLazilyUpdateOnCacheHit) {
                     getCloudflareContext().ctx.waitUntil(this.store.get(key, isFetch).then(async (rawEntry) => {
                         const { value, lastModified } = rawEntry ?? {};
                         if (value && typeof lastModified === "number") {
-                            await this.putToCache(localCacheKey, { value, lastModified });
+                            await this.putToCache({ key, isFetch, entry: { value, lastModified } });
                         }
                     }));
                 }
@@ -44,7 +45,7 @@ class RegionalCache {
             if (!value || typeof lastModified !== "number")
                 return null;
             // Update the locale cache after retrieving from the store.
-            getCloudflareContext().ctx.waitUntil(this.putToCache(localCacheKey, { value, lastModified }));
+            getCloudflareContext().ctx.waitUntil(this.putToCache({ key, isFetch, entry: { value, lastModified } }));
             return { value, lastModified };
         }
         catch (e) {
@@ -55,11 +56,15 @@ class RegionalCache {
     async set(key, value, isFetch) {
         try {
             await this.store.set(key, value, isFetch);
-            await this.putToCache(this.getCacheKey(key, isFetch), {
-                value,
-                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
-                //       See https://developers.cloudflare.com/workers/reference/security-model/
-                lastModified: Date.now(),
+            await this.putToCache({
+                key,
+                isFetch,
+                entry: {
+                    value,
+                    // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                    //       See https://developers.cloudflare.com/workers/reference/security-model/
+                    lastModified: Date.now(),
+                },
             });
         }
         catch (e) {
@@ -70,7 +75,7 @@ class RegionalCache {
         try {
             await this.store.delete(key);
             const cache = await this.getCacheInstance();
-            await cache.delete(this.getCacheKey(key));
+            await cache.delete(this.getCacheUrlKey(key));
         }
         catch (e) {
             error("Failed to delete from regional cache", e);
@@ -82,16 +87,28 @@ class RegionalCache {
         this.localCache = await caches.open("incremental-cache");
         return this.localCache;
     }
-    getCacheKey(key, isFetch) {
-        return new Request(new URL(`${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`, "http://cache.local"));
+    getCacheUrlKey(key, isFetch) {
+        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+        return ("http://cache.local" + `/${buildId}/${key}`.replace(/\/+/g, "/") + `.${isFetch ? "fetch" : "cache"}`);
     }
-    async putToCache(key, entry) {
+    async putToCache({ key, isFetch, entry }) {
+        const urlKey = this.getCacheUrlKey(key, isFetch);
         const cache = await this.getCacheInstance();
         const age = this.opts.mode === "short-lived"
             ? ONE_MINUTE_IN_SECONDS
-            : entry.value.revalidate || THIRTY_MINUTES_IN_SECONDS;
-        await cache.put(key, new Response(JSON.stringify(entry), {
-            headers: new Headers({ "cache-control": `max-age=${age}` }),
+            : entry.value.revalidate || this.opts.defaultLongLivedTtlSec || THIRTY_MINUTES_IN_SECONDS;
+        // We default to the entry key if no tags are found.
+        // so that we can also revalidate page router based entry this way.
+        const tags = getTagsFromCacheEntry(entry) ?? [key];
+        await cache.put(urlKey, new Response(JSON.stringify(entry), {
+            headers: new Headers({
+                "cache-control": `max-age=${age}`,
+                ...(tags.length > 0
+                    ? {
+                        "cache-tag": tags.join(","),
+                    }
+                    : {}),
+            }),
         }));
     }
 }
@@ -112,9 +129,29 @@ class RegionalCache {
  *                                  or an ISR/SSG entry for up to 30 minutes.
  * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
  *                                          the background or not when it experiences a cache hit.
+ * @param opts.defaultLongLivedTtlSec The default age to use for long-lived cache entries.
+ *                                  When no revalidate is provided, the default age will be used.
+ *                                  @default `THIRTY_MINUTES_IN_SECONDS`
  *
  * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export function withRegionalCache(cache, opts) {
     return new RegionalCache(cache, opts);
 }
+/**
+ * Extract the list of tags from a cache entry.
+ */
+function getTagsFromCacheEntry(entry) {
+    if ("tags" in entry.value && entry.value.tags) {
+        return entry.value.tags;
+    }
+    if ("meta" in entry.value &&
+        entry.value.meta &&
+        "headers" in entry.value.meta &&
+        entry.value.meta.headers) {
+        const rawTags = entry.value.meta.headers["x-next-cache-tags"];
+        if (typeof rawTags === "string") {
+            return rawTags.split(",");
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+export declare const CACHE_DIR = "cdn-cgi/_next_cache";
+export declare const NAME = "cf-static-assets-incremental-cache";
+/**
+ * This cache uses Workers static assets.
+ *
+ * It should only be used for applications that do NOT want revalidation and ONLY want to serve prerendered data.
+ */
+declare class StaticAssetsIncrementalCache implements IncrementalCache {
+    readonly name = "cf-static-assets-incremental-cache";
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
+    set(): Promise<void>;
+    delete(): Promise<void>;
+    protected getAssetUrl(key: string, isFetch?: boolean): string;
+}
+declare const _default: StaticAssetsIncrementalCache;
+export default _default;

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

@@ -0,0 +1,46 @@
+import { error } from "@opennextjs/aws/adapters/logger.js";
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
+//  Assets inside `cdn-cgi/...` are only accessible by the worker.
+export const CACHE_DIR = "cdn-cgi/_next_cache";
+export const NAME = "cf-static-assets-incremental-cache";
+/**
+ * This cache uses Workers static assets.
+ *
+ * It should only be used for applications that do NOT want revalidation and ONLY want to serve prerendered data.
+ */
+class StaticAssetsIncrementalCache {
+    name = NAME;
+    async get(key, isFetch) {
+        const assets = getCloudflareContext().env.ASSETS;
+        if (!assets)
+            throw new IgnorableError("No Static Assets");
+        debugCache(`Get ${key}`);
+        try {
+            const response = await assets.fetch(this.getAssetUrl(key, isFetch));
+            if (!response.ok)
+                return null;
+            return {
+                value: await response.json(),
+                lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+            };
+        }
+        catch (e) {
+            error("Failed to get from cache", e);
+            return null;
+        }
+    }
+    async set() {
+        error("Failed to set to read-only cache");
+    }
+    async delete() {
+        error("Failed to delete from read-only cache");
+    }
+    getAssetUrl(key, isFetch) {
+        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+        const name = (isFetch ? `${CACHE_DIR}/__fetch/${buildId}/${key}` : `${CACHE_DIR}/${buildId}/${key}.cache`).replace(/\/+/g, "/");
+        return `http://assets.local/${name}`;
+    }
+}
+export default new StaticAssetsIncrementalCache();

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

@@ -3,3 +3,5 @@ export type IncrementalCacheEntry<IsFetch extends boolean> = {
     value: CacheValue<IsFetch>;
     lastModified: number;
 };
+export declare const debugCache: (name: string, ...args: unknown[]) => void;
+export declare const FALLBACK_BUILD_ID = "no-build-id";

package/dist/api/overrides/internal.js

@@ -0,0 +1,6 @@
+export const debugCache = (name, ...args) => {
+    if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+        console.log(`[${name}] `, ...args);
+    }
+};
+export const FALLBACK_BUILD_ID = "no-build-id";

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

@@ -1,6 +1,7 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
+import { debugCache } from "../internal";
 export const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 /**
  * The Memory Queue offers basic ISR revalidation by directly requesting a revalidation of a route.
@@ -41,7 +42,7 @@ export class MemoryQueue {
             if (response.status !== 200 || response.headers.get("x-nextjs-cache") !== "REVALIDATED") {
                 error(`Revalidation failed for ${url} with status ${response.status}`);
             }
-            debug(`Revalidation successful for ${url}`);
+            debugCache(`Revalidation successful for ${url}`);
         }
         catch (e) {
             error(e);

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

@@ -1,12 +1,12 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "d1-next-mode-tag-cache";
+export declare const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export declare class D1NextModeTagCache implements NextModeTagCache {
     readonly mode: "nextMode";
     readonly name = "d1-next-mode-tag-cache";
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
     writeTags(tags: string[]): Promise<void>;
     private getConfig;
-    protected removeBuildId(key: string): string;
     protected getCacheKey(key: string): string;
     protected getBuildId(): string;
 }

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

@@ -1,7 +1,8 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
-import { RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "d1-next-mode-tag-cache";
+export const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export class D1NextModeTagCache {
     mode = "nextMode";
     name = NAME;
@@ -25,19 +26,17 @@ export class D1NextModeTagCache {
     }
     async writeTags(tags) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        // 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 result = await db.batch(tags.map((tag) => db
+        await db.batch(tags.map((tag) => db
             .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
             .bind(this.getCacheKey(tag), Date.now())));
-        if (!result)
-            throw new RecoverableError(`D1 insert failed for ${tags}`);
     }
     getConfig() {
-        const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_TAG_CACHE_D1;
+        const db = getCloudflareContext().env[BINDING_NAME];
         if (!db)
-            debug("No D1 database found");
+            debugCache("No D1 database found");
         const isDisabled = !!globalThis.openNextConfig
             .dangerous?.disableTagCache;
         return !db || isDisabled
@@ -47,14 +46,11 @@ export class D1NextModeTagCache {
                 db,
             };
     }
-    removeBuildId(key) {
-        return key.replace(`${this.getBuildId()}/`, "");
-    }
     getCacheKey(key) {
         return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
     }
     getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+        return process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
     }
 }
 export default new D1NextModeTagCache();