@opennextjs/cloudflare 1.8.0 → 1.8.1

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

@@ -9,4 +9,4 @@ export declare const purgeCache: ({ type }: PurgeOptions) => {
         resolvedRoutes: import("@opennextjs/aws/types/open-next.js").ResolvedRoute[];
     }[]): Promise<void>;
 };
-export {};
+export default purgeCache;

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

@@ -25,3 +25,4 @@ export const purgeCache = ({ type = "direct" }) => {
         },
     };
 };
+export default purgeCache;

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

@@ -20,13 +20,15 @@ type Options = {
      * Whether the regional cache entry should be updated in the background or not when it experiences
      * a cache hit.
      *
-     * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+     * @default `true` in `long-lived` mode when cache purge is not used, `false` otherwise.
      */
     shouldLazilyUpdateOnCacheHit?: boolean;
     /**
      * Whether on cache hits the tagCache should be skipped or not. Skipping the tagCache allows requests to be
-     * handled faster, the downside of this is that you need to make sure that the cache gets correctly purged
-     * either by enabling the auto cache purging feature or doing that manually.
+     * handled faster,
+     *
+     * Note: When this is enabled, make sure that the cache gets purged
+     *       either by enabling the auto cache purging feature or manually.
      *
      * @default `true` if the auto cache purging is enabled, `false` otherwise.
      */
@@ -38,7 +40,16 @@ interface PutToCacheInput {
     entry: IncrementalCacheEntry<CacheEntryType>;
 }
 /**
- * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation.
+ *
+ * Using a the `RegionalCache` does not directly improves the performance much.
+ * However it allows bypassing the tag cache (see `bypassTagCacheOnCacheHit`) on hits.
+ * That's where bigger perf gain happens.
+ *
+ * We recommend using cache purge.
+ * When cache purge is not enabled, there is a possibility that the Cache API (local to a Data Center)
+ * is out of sync with the cache store (i.e. R2). That's why when cache purge is not enabled the Cache
+ * API is refreshed from the cache store on cache hits (for the long-lived mode).
  */
 declare class RegionalCache implements IncrementalCache {
     #private;

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

@@ -5,7 +5,16 @@ 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;
 /**
- * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation.
+ *
+ * Using a the `RegionalCache` does not directly improves the performance much.
+ * However it allows bypassing the tag cache (see `bypassTagCacheOnCacheHit`) on hits.
+ * That's where bigger perf gain happens.
+ *
+ * We recommend using cache purge.
+ * When cache purge is not enabled, there is a possibility that the Cache API (local to a Data Center)
+ * is out of sync with the cache store (i.e. R2). That's why when cache purge is not enabled the Cache
+ * API is refreshed from the cache store on cache hits (for the long-lived mode).
  */
 class RegionalCache {
     store;
@@ -19,7 +28,8 @@ 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.opts.shouldLazilyUpdateOnCacheHit ??=
+            this.opts.mode === "long-lived" && !this.#hasAutomaticCachePurging;
     }
     get #bypassTagCacheOnCacheHit() {
         if (this.opts.bypassTagCacheOnCacheHit !== undefined) {
@@ -27,8 +37,11 @@ class RegionalCache {
             return this.opts.bypassTagCacheOnCacheHit;
         }
         // Otherwise we default to whether the automatic cache purging is enabled or not
-        const hasAutomaticCachePurging = !!getCloudflareContext().env.NEXT_CACHE_DO_PURGE;
-        return hasAutomaticCachePurging;
+        return this.#hasAutomaticCachePurging;
+    }
+    get #hasAutomaticCachePurging() {
+        const cdnInvalidation = globalThis.openNextConfig.default?.override?.cdnInvalidation;
+        return cdnInvalidation !== undefined && cdnInvalidation !== "dummy";
     }
     async get(key, cacheType) {
         try {
@@ -38,7 +51,8 @@ class RegionalCache {
             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
+                // 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) {
                     getCloudflareContext().ctx.waitUntil(this.store.get(key, cacheType).then(async (rawEntry) => {
                         const { value, lastModified } = rawEntry ?? {};

package/dist/cli/build/open-next/compile-init.js

@@ -12,6 +12,7 @@ export async function compileInit(options, wranglerConfig) {
     const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
     const basePath = nextConfig.basePath ?? "";
     const deploymentId = nextConfig.deploymentId ?? "";
+    const trailingSlash = nextConfig.trailingSlash ?? false;
     await build({
         entryPoints: [initPath],
         outdir: path.join(options.outputDir, "cloudflare"),
@@ -25,6 +26,7 @@ export async function compileInit(options, wranglerConfig) {
             __NEXT_BASE_PATH__: JSON.stringify(basePath),
             __ASSETS_RUN_WORKER_FIRST__: JSON.stringify(wranglerConfig.assets?.run_worker_first ?? false),
             __DEPLOYMENT_ID__: JSON.stringify(deploymentId),
+            __TRAILING_SLASH__: JSON.stringify(trailingSlash),
         },
     });
 }

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

@@ -12,4 +12,5 @@ declare global {
     var __NEXT_BASE_PATH__: string;
     var __ASSETS_RUN_WORKER_FIRST__: boolean | string[] | undefined;
     var __DEPLOYMENT_ID__: string;
+    var __TRAILING_SLASH__: boolean;
 }

package/dist/cli/templates/init.js

@@ -76,6 +76,7 @@ function initRuntime() {
         __BUILD_TIMESTAMP_MS__,
         __NEXT_BASE_PATH__,
         __ASSETS_RUN_WORKER_FIRST__,
+        __TRAILING_SLASH__,
         // The external middleware will use the convertTo function of the `edge` converter
         // by default it will try to fetch the request, but since we are running everything in the same worker
         // we need to use the request as is.

package/dist/cli/templates/worker.js

@@ -33,7 +33,8 @@ export default {
                     : env.ASSETS?.fetch(new URL(`/${imageUrl}`, url));
             }
             // Fallback for the Next default image loader.
-            if (url.pathname === `${globalThis.__NEXT_BASE_PATH__}/_next/image`) {
+            if (url.pathname ===
+                `${globalThis.__NEXT_BASE_PATH__}/_next/image${globalThis.__TRAILING_SLASH__ ? "/" : ""}`) {
                 const imageUrl = url.searchParams.get("url") ?? "";
                 return await fetchImage(env.ASSETS, imageUrl, ctx);
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"