@opennextjs/cloudflare 1.0.0-beta.4 → 1.0.0

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

@@ -1,14 +1,17 @@
 import type { GetPlatformProxyOptions } from "wrangler";
-import type { DOQueueHandler } from "./durable-objects/queue";
-import { DOShardedTagCache } from "./durable-objects/sharded-tag-cache";
+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";
+import type { PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME } from "./overrides/incremental-cache/r2-incremental-cache.js";
 declare global {
     interface CloudflareEnv {
         ASSETS?: Fetcher;
         NEXTJS_ENV?: string;
         WORKER_SELF_REFERENCE?: Service;
         NEXT_INC_CACHE_KV?: KVNamespace;
+        [KV_CACHE_PREFIX_ENV_NAME]?: string;
         NEXT_INC_CACHE_R2_BUCKET?: R2Bucket;
-        NEXT_INC_CACHE_R2_PREFIX?: string;
+        [R2_CACHE_PREFIX_ENV_NAME]?: string;
         NEXT_TAG_CACHE_D1?: D1Database;
         NEXT_TAG_CACHE_DO_SHARDED?: DurableObjectNamespace<DOShardedTagCache>;
         NEXT_TAG_CACHE_DO_SHARDED_DLQ?: Queue;

package/dist/api/config.d.ts

@@ -1,4 +1,5 @@
-import { BaseOverride, LazyLoadedOverride, OpenNextConfig } from "@opennextjs/aws/types/open-next";
+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";
 export type Override<T extends BaseOverride> = "dummy" | T | LazyLoadedOverride<T>;
 /**
@@ -19,6 +20,12 @@ export type CloudflareOverrides = {
      * Sets the revalidation queue implementation
      */
     queue?: "direct" | Override<Queue>;
+    /**
+     * Enable cache interception
+     * Should be `false` when PPR is used
+     * @default false
+     */
+    enableCacheInterception?: boolean;
 };
 /**
  * Defines the OpenNext configuration that targets the Cloudflare adapter
@@ -27,3 +34,23 @@ export type CloudflareOverrides = {
  * @returns the OpenNext configuration object
  */
 export declare function defineCloudflareConfig(config?: CloudflareOverrides): OpenNextConfig;
+interface OpenNextConfig extends AwsOpenNextConfig {
+    cloudflare?: {
+        /**
+         * Whether to use the "workerd" build conditions when bundling the server.
+         * It is recommended to set it to `true` so that code specifically targeted to the
+         * workerd runtime is bundled.
+         *
+         * See https://esbuild.github.io/api/#conditions
+         *
+         * @default true
+         */
+        useWorkerdCondition?: boolean;
+    };
+}
+/**
+ * @param buildOpts build options from AWS
+ * @returns The OpenConfig specific to cloudflare
+ */
+export declare function getOpenNextConfig(buildOpts: BuildOptions): OpenNextConfig;
+export type { OpenNextConfig };

package/dist/api/config.js

@@ -5,7 +5,7 @@
  * @returns the OpenNext configuration object
  */
 export function defineCloudflareConfig(config = {}) {
-    const { incrementalCache, tagCache, queue } = config;
+    const { incrementalCache, tagCache, queue, enableCacheInterception = false } = config;
     return {
         default: {
             override: {
@@ -16,9 +16,16 @@ export function defineCloudflareConfig(config = {}) {
                 tagCache: resolveTagCache(tagCache),
                 queue: resolveQueue(queue),
             },
+            routePreloadingBehavior: "withWaitUntil",
         },
         // node:crypto is used to compute cache keys
         edgeExternals: ["node:crypto"],
+        cloudflare: {
+            useWorkerdCondition: true,
+        },
+        dangerous: {
+            enableCacheInterception,
+        },
     };
 }
 function resolveIncrementalCache(value = "dummy") {
@@ -39,3 +46,10 @@ function resolveQueue(value = "dummy") {
     }
     return typeof value === "function" ? value : () => value;
 }
+/**
+ * @param buildOpts build options from AWS
+ * @returns The OpenConfig specific to cloudflare
+ */
+export function getOpenNextConfig(buildOpts) {
+    return buildOpts.config;
+}

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

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

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

@@ -8,6 +8,22 @@ export class DOShardedTagCache extends DurableObject {
             this.sql.exec(`CREATE TABLE IF NOT EXISTS revalidations (tag TEXT PRIMARY KEY, revalidatedAt INTEGER)`);
         });
     }
+    async getLastRevalidated(tags) {
+        try {
+            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;
+        }
+        catch (e) {
+            console.error(e);
+            // By default we don't want to crash here, so we return 0
+            return 0;
+        }
+    }
     async hasBeenRevalidated(tags, lastModified) {
         return (this.sql
             .exec(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`, ...tags, lastModified ?? Date.now())

package/dist/api/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./cloudflare-context.js";
-export { defineCloudflareConfig } from "./config.js";
+export { defineCloudflareConfig, type OpenNextConfig } from "./config.js";

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

@@ -1,24 +1,23 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+import type { CacheEntryType, 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;
+export declare const PREFIX_ENV_NAME = "NEXT_INC_CACHE_KV_PREFIX";
 /**
  * Open Next cache based on Cloudflare KV.
  *
+ * The prefix that the cache entries are stored under can be configured with the `NEXT_INC_CACHE_KV_PREFIX`
+ * environment variable, and defaults to `incremental-cache`.
+ *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
 declare class KVIncrementalCache implements IncrementalCache {
     readonly name = "cf-kv-incremental-cache";
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, value: CacheValue<CacheType>, cacheType?: CacheType): Promise<void>;
     delete(key: string): Promise<void>;
-    protected getKVKey(key: string, isFetch?: boolean): string;
+    protected getKVKey(key: string, cacheType?: CacheEntryType): string;
 }
 declare const _default: KVIncrementalCache;
 export default _default;

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

@@ -1,31 +1,29 @@
-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";
+import { computeCacheKey, debugCache } 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, "/");
-}
+export const PREFIX_ENV_NAME = "NEXT_INC_CACHE_KV_PREFIX";
 /**
  * Open Next cache based on Cloudflare KV.
  *
+ * The prefix that the cache entries are stored under can be configured with the `NEXT_INC_CACHE_KV_PREFIX`
+ * environment variable, and defaults to `incremental-cache`.
+ *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
 class KVIncrementalCache {
     name = NAME;
-    async get(key, isFetch) {
+    async get(key, cacheType) {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
         debugCache(`Get ${key}`);
         try {
-            const entry = await kv.get(this.getKVKey(key, isFetch), "json");
+            const entry = await kv.get(this.getKVKey(key, cacheType), "json");
             if (!entry)
                 return null;
             if ("lastModified" in entry) {
@@ -42,13 +40,13 @@ class KVIncrementalCache {
             return null;
         }
     }
-    async set(key, value, isFetch) {
+    async set(key, value, cacheType) {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
         debugCache(`Set ${key}`);
         try {
-            await kv.put(this.getKVKey(key, isFetch), JSON.stringify({
+            await kv.put(this.getKVKey(key, cacheType), 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/
@@ -68,16 +66,18 @@ class KVIncrementalCache {
             throw new IgnorableError("No KV Namespace");
         debugCache(`Delete ${key}`);
         try {
-            await kv.delete(this.getKVKey(key, /* isFetch= */ false));
+            // Only cache that gets deleted is the ISR/SSG cache.
+            await kv.delete(this.getKVKey(key, "cache"));
         }
         catch (e) {
             error("Failed to delete from cache", e);
         }
     }
-    getKVKey(key, isFetch) {
+    getKVKey(key, cacheType) {
         return computeCacheKey(key, {
+            prefix: getCloudflareContext().env[PREFIX_ENV_NAME],
             buildId: process.env.NEXT_BUILD_ID,
-            isFetch,
+            cacheType,
         });
     }
 }

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

@@ -1,14 +1,7 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+import type { CacheEntryType, 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.
@@ -18,10 +11,10 @@ export declare function computeCacheKey(key: string, options: KeyOptions): strin
  */
 declare class R2IncrementalCache implements IncrementalCache {
     readonly name = "cf-r2-incremental-cache";
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, value: CacheValue<CacheType>, cacheType?: CacheType): Promise<void>;
     delete(key: string): Promise<void>;
-    protected getR2Key(key: string, isFetch?: boolean): string;
+    protected getR2Key(key: string, cacheType?: CacheEntryType): string;
 }
 declare const _default: R2IncrementalCache;
 export default _default;

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

@@ -1,17 +1,10 @@
-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";
+import { computeCacheKey, debugCache } 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.
@@ -21,13 +14,13 @@ export function computeCacheKey(key, options) {
  */
 class R2IncrementalCache {
     name = NAME;
-    async get(key, isFetch) {
+    async get(key, cacheType) {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
         debugCache(`Get ${key}`);
         try {
-            const r2Object = await r2.get(this.getR2Key(key, isFetch));
+            const r2Object = await r2.get(this.getR2Key(key, cacheType));
             if (!r2Object)
                 return null;
             return {
@@ -40,13 +33,13 @@ class R2IncrementalCache {
             return null;
         }
     }
-    async set(key, value, isFetch) {
+    async set(key, value, cacheType) {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
         debugCache(`Set ${key}`);
         try {
-            await r2.put(this.getR2Key(key, isFetch), JSON.stringify(value));
+            await r2.put(this.getR2Key(key, cacheType), JSON.stringify(value));
         }
         catch (e) {
             error("Failed to set to cache", e);
@@ -64,11 +57,11 @@ class R2IncrementalCache {
             error("Failed to delete from cache", e);
         }
     }
-    getR2Key(key, isFetch) {
+    getR2Key(key, cacheType) {
         return computeCacheKey(key, {
-            directory: getCloudflareContext().env[PREFIX_ENV_NAME],
+            prefix: getCloudflareContext().env[PREFIX_ENV_NAME],
             buildId: process.env.NEXT_BUILD_ID,
-            isFetch,
+            cacheType,
         });
     }
 }

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

@@ -1,4 +1,4 @@
-import { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+import { CacheEntryType, CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 import { IncrementalCacheEntry } from "../internal.js";
 type Options = {
     /**
@@ -26,8 +26,8 @@ type Options = {
 };
 interface PutToCacheInput {
     key: string;
-    isFetch: boolean | undefined;
-    entry: IncrementalCacheEntry<boolean>;
+    cacheType?: CacheEntryType;
+    entry: IncrementalCacheEntry<CacheEntryType>;
 }
 /**
  * Wrapper adding a regional cache on an `IncrementalCache` implementation
@@ -38,12 +38,12 @@ declare class RegionalCache implements IncrementalCache {
     name: string;
     protected localCache: Cache | undefined;
     constructor(store: IncrementalCache, opts: Options);
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, value: CacheValue<CacheType>, cacheType?: CacheType): Promise<void>;
     delete(key: string): Promise<void>;
     protected getCacheInstance(): Promise<Cache>;
-    protected getCacheUrlKey(key: string, isFetch?: boolean): string;
-    protected putToCache({ key, isFetch, entry }: PutToCacheInput): Promise<void>;
+    protected getCacheUrlKey(key: string, cacheType?: CacheEntryType): string;
+    protected putToCache({ key, cacheType, entry }: PutToCacheInput): Promise<void>;
 }
 /**
  * A regional cache will wrap an incremental cache and provide faster cache lookups for an entry

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

@@ -21,31 +21,31 @@ class RegionalCache {
         this.name = this.store.name;
         this.opts.shouldLazilyUpdateOnCacheHit ??= this.opts.mode === "long-lived";
     }
-    async get(key, isFetch) {
+    async get(key, cacheType) {
         try {
             const cache = await this.getCacheInstance();
-            const urlKey = this.getCacheUrlKey(key, isFetch);
+            const urlKey = this.getCacheUrlKey(key, cacheType);
             // 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");
                 // 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) => {
+                    getCloudflareContext().ctx.waitUntil(this.store.get(key, cacheType).then(async (rawEntry) => {
                         const { value, lastModified } = rawEntry ?? {};
                         if (value && typeof lastModified === "number") {
-                            await this.putToCache({ key, isFetch, entry: { value, lastModified } });
+                            await this.putToCache({ key, cacheType, entry: { value, lastModified } });
                         }
                     }));
                 }
                 return cachedResponse.json();
             }
-            const rawEntry = await this.store.get(key, isFetch);
+            const rawEntry = await this.store.get(key, cacheType);
             const { value, lastModified } = rawEntry ?? {};
             if (!value || typeof lastModified !== "number")
                 return null;
             // Update the locale cache after retrieving from the store.
-            getCloudflareContext().ctx.waitUntil(this.putToCache({ key, isFetch, entry: { value, lastModified } }));
+            getCloudflareContext().ctx.waitUntil(this.putToCache({ key, cacheType, entry: { value, lastModified } }));
             return { value, lastModified };
         }
         catch (e) {
@@ -53,12 +53,12 @@ class RegionalCache {
             return null;
         }
     }
-    async set(key, value, isFetch) {
+    async set(key, value, cacheType) {
         try {
-            await this.store.set(key, value, isFetch);
+            await this.store.set(key, value, cacheType);
             await this.putToCache({
                 key,
-                isFetch,
+                cacheType,
                 entry: {
                     value,
                     // Note: `Date.now()` returns the time of the last IO rather than the actual time.
@@ -87,12 +87,12 @@ class RegionalCache {
         this.localCache = await caches.open("incremental-cache");
         return this.localCache;
     }
-    getCacheUrlKey(key, isFetch) {
+    getCacheUrlKey(key, cacheType) {
         const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
-        return ("http://cache.local" + `/${buildId}/${key}`.replace(/\/+/g, "/") + `.${isFetch ? "fetch" : "cache"}`);
+        return "http://cache.local" + `/${buildId}/${key}`.replace(/\/+/g, "/") + `.${cacheType ?? "cache"}`;
     }
-    async putToCache({ key, isFetch, entry }) {
-        const urlKey = this.getCacheUrlKey(key, isFetch);
+    async putToCache({ key, cacheType, entry }) {
+        const urlKey = this.getCacheUrlKey(key, cacheType);
         const cache = await this.getCacheInstance();
         const age = this.opts.mode === "short-lived"
             ? ONE_MINUTE_IN_SECONDS
@@ -154,4 +154,7 @@ function getTagsFromCacheEntry(entry) {
             return rawTags.split(",");
         }
     }
+    if ("value" in entry.value) {
+        return entry.value.tags;
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+import type { CacheEntryType, 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";
 /**
@@ -8,10 +8,10 @@ export declare const NAME = "cf-static-assets-incremental-cache";
  */
 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>;
+    get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
     set(): Promise<void>;
     delete(): Promise<void>;
-    protected getAssetUrl(key: string, isFetch?: boolean): string;
+    protected getAssetUrl(key: string, cacheType?: CacheEntryType): string;
 }
 declare const _default: StaticAssetsIncrementalCache;
 export default _default;

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

@@ -12,13 +12,13 @@ export const NAME = "cf-static-assets-incremental-cache";
  */
 class StaticAssetsIncrementalCache {
     name = NAME;
-    async get(key, isFetch) {
+    async get(key, cacheType) {
         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));
+            const response = await assets.fetch(this.getAssetUrl(key, cacheType));
             if (!response.ok)
                 return null;
             return {
@@ -37,9 +37,14 @@ class StaticAssetsIncrementalCache {
     async delete() {
         error("Failed to delete from read-only cache");
     }
-    getAssetUrl(key, isFetch) {
+    getAssetUrl(key, cacheType) {
+        if (cacheType === "composable") {
+            throw new Error("Composable cache is not supported in static assets incremental cache");
+        }
         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, "/");
+        const name = (cacheType === "fetch"
+            ? `${CACHE_DIR}/__fetch/${buildId}/${key}`
+            : `${CACHE_DIR}/${buildId}/${key}.cache`).replace(/\/+/g, "/");
         return `http://assets.local/${name}`;
     }
 }

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

@@ -1,7 +1,14 @@
-import { CacheValue } from "@opennextjs/aws/types/overrides.js";
-export type IncrementalCacheEntry<IsFetch extends boolean> = {
-    value: CacheValue<IsFetch>;
+import type { CacheEntryType, CacheValue } from "@opennextjs/aws/types/overrides.js";
+export type IncrementalCacheEntry<CacheType extends CacheEntryType> = {
+    value: CacheValue<CacheType>;
     lastModified: number;
 };
 export declare const debugCache: (name: string, ...args: unknown[]) => void;
 export declare const FALLBACK_BUILD_ID = "no-build-id";
+export declare const DEFAULT_PREFIX = "incremental-cache";
+export type KeyOptions = {
+    cacheType?: CacheEntryType;
+    prefix: string | undefined;
+    buildId: string | undefined;
+};
+export declare function computeCacheKey(key: string, options: KeyOptions): string;

package/dist/api/overrides/internal.js

@@ -1,6 +1,13 @@
+import { createHash } from "node:crypto";
 export const debugCache = (name, ...args) => {
     if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
         console.log(`[${name}] `, ...args);
     }
 };
 export const FALLBACK_BUILD_ID = "no-build-id";
+export const DEFAULT_PREFIX = "incremental-cache";
+export function computeCacheKey(key, options) {
+    const { cacheType = "cache", prefix = DEFAULT_PREFIX, buildId = FALLBACK_BUILD_ID } = options;
+    const hash = createHash("sha256").update(key).digest("hex");
+    return `${prefix}/${buildId}/${hash}.${cacheType}`.replace(/\/+/g, "/");
+}

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

@@ -4,6 +4,7 @@ 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";
+    getLastRevalidated(tags: string[]): Promise<number>;
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
     writeTags(tags: string[]): Promise<void>;
     private getConfig;

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

@@ -6,6 +6,26 @@ export const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export class D1NextModeTagCache {
     mode = "nextMode";
     name = NAME;
+    async getLastRevalidated(tags) {
+        const { isDisabled, db } = this.getConfig();
+        if (isDisabled)
+            return 0;
+        try {
+            const result = await db
+                .prepare(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`)
+                .run();
+            if (result.results.length === 0)
+                return 0;
+            // We only care about the most recent revalidation
+            return (result.results[0]?.time ?? 0);
+        }
+        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
+            return 0;
+        }
+    }
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled, db } = this.getConfig();
         if (isDisabled)

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

@@ -71,6 +71,11 @@ export declare class DOId {
     private generateRandomNumberBetween;
     get key(): string;
 }
+interface CacheTagKeyOptions {
+    doId: DOId;
+    tags: string[];
+    type: "boolean" | "number";
+}
 declare class ShardedDOTagCache implements NextModeTagCache {
     private opts;
     readonly mode: "nextMode";
@@ -102,6 +107,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
         tags: string[];
     }[];
     private getConfig;
+    getLastRevalidated(tags: string[]): Promise<number>;
     /**
      * This function checks if the tags have been revalidated
      * It is never supposed to throw and in case of error, it will return false
@@ -119,10 +125,10 @@ declare class ShardedDOTagCache implements NextModeTagCache {
     writeTags(tags: string[]): Promise<void>;
     performWriteTagsWithRetry(doId: DOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
     getCacheInstance(): Promise<Cache | undefined>;
-    getCacheUrlKey(doId: DOId, tags: string[]): string;
-    getFromRegionalCache(doId: DOId, tags: string[]): Promise<Response | undefined>;
-    putToRegionalCache(doId: DOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
-    deleteRegionalCache(doId: DOId, tags: string[]): Promise<void>;
+    getCacheUrlKey(opts: CacheTagKeyOptions): string;
+    getFromRegionalCache(opts: CacheTagKeyOptions): Promise<Response | undefined>;
+    putToRegionalCache(optsKey: CacheTagKeyOptions, value: number | boolean): Promise<void>;
+    deleteRegionalCache(optsKey: CacheTagKeyOptions): Promise<void>;
 }
 declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;
 export default _default;