@opennextjs/cloudflare 1.6.1 → 1.6.3

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

@@ -5,4 +5,5 @@ export declare class DOShardedTagCache extends DurableObject<CloudflareEnv> {
     getLastRevalidated(tags: string[]): Promise<number>;
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
     writeTags(tags: string[], lastModified: number): Promise<void>;
+    getRevalidationTimes(tags: string[]): Promise<Record<string, number>>;
 }

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

@@ -34,4 +34,10 @@ export class DOShardedTagCache extends DurableObject {
             this.sql.exec(`INSERT OR REPLACE INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`, tag, lastModified);
         });
     }
+    async getRevalidationTimes(tags) {
+        const result = this.sql
+            .exec(`SELECT tag, revalidatedAt FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`, ...tags)
+            .toArray();
+        return Object.fromEntries(result.map((row) => [row.tag, row.revalidatedAt]));
+    }
 }

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

@@ -1,4 +1,5 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
+import { DOShardedTagCache } from "../../durable-objects/sharded-tag-cache.js";
 export declare const DEFAULT_WRITE_RETRIES = 3;
 export declare const DEFAULT_NUM_SHARDS = 4;
 export declare const NAME = "do-sharded-tag-cache";
@@ -34,6 +35,13 @@ interface ShardedDOTagCacheOptions {
      * @default 5
      */
     regionalCacheTtlSec?: number;
+    /**
+     * Whether to persist missing tags in the regional cache.
+     * This is dangerous if you don't invalidate the Cache API when you revalidate tags as you could end up storing stale data in the data cache.
+     *
+     * @default false
+     */
+    regionalCacheDangerouslyPersistMissingTags?: boolean;
     /**
      * Enable shard replication to handle higher load.
      *
@@ -91,7 +99,6 @@ export declare class DOId {
 interface CacheTagKeyOptions {
     doId: DOId;
     tags: string[];
-    type: "boolean" | "number";
 }
 declare class ShardedDOTagCache implements NextModeTagCache {
     private opts;
@@ -145,9 +152,21 @@ 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(opts: CacheTagKeyOptions): string;
-    getFromRegionalCache(opts: CacheTagKeyOptions): Promise<Response | undefined>;
-    putToRegionalCache(optsKey: CacheTagKeyOptions, value: number | boolean): Promise<void>;
+    getCacheUrlKey(doId: DOId, tag: string): string;
+    /**
+     * Get the last revalidation time for the tags from the regional cache
+     * If the cache is not enabled, it will return an empty array
+     * @returns An array of objects with the tag and the last revalidation time
+     */
+    getFromRegionalCache(opts: CacheTagKeyOptions): Promise<{
+        tag: string;
+        time: number;
+    }[]>;
+    putToRegionalCache(optsKey: CacheTagKeyOptions, stub: DurableObjectStub<DOShardedTagCache>): Promise<void>;
+    /**
+     * Deletes the regional cache for the given tags
+     * This is used to ensure that the cache is cleared when the tags are revalidated
+     */
     deleteRegionalCache(optsKey: CacheTagKeyOptions): Promise<void>;
 }
 declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;

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

@@ -179,26 +179,25 @@ class ShardedDOTagCache {
         const { isDisabled } = await this.getConfig();
         if (isDisabled)
             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 });
+            const shardedTagGroups = this.groupTagsByDO({ tags: deduplicatedTags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "number" });
-                if (cachedValue) {
-                    const cached = await cachedValue.text();
-                    try {
-                        return parseInt(cached, 10);
-                    }
-                    catch (e) {
-                        debug("Error while parsing cached value", e);
-                        // If we can't parse the cached value, we should just ignore it and go to the durable object
-                    }
+                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));
                 }
+                // 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(tags);
-                if (!_lastRevalidated) {
-                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "number" }, _lastRevalidated));
-                }
-                return _lastRevalidated;
+                const lastRevalidated = await stub.getLastRevalidated(filteredTags);
+                const result = 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;
             }));
             return Math.max(...shardedTagRevalidationOutcomes);
         }
@@ -221,17 +220,20 @@ class ShardedDOTagCache {
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "boolean" });
-                if (cachedValue) {
-                    return (await cachedValue.text()) === "true";
+                const cachedValue = await this.getFromRegionalCache({ doId, tags });
+                // If one of the cached values is newer than the lastModified, we can return true
+                const cacheHasBeenRevalidated = cachedValue.some((cachedValue) => {
+                    return (cachedValue.time ?? 0) > (lastModified ?? Date.now());
+                });
+                if (cacheHasBeenRevalidated) {
+                    return true;
                 }
                 const stub = this.getDurableObjectStub(doId);
                 const _hasBeenRevalidated = await stub.hasBeenRevalidated(tags, lastModified);
-                //TODO: Do we want to cache the result if it has been revalidated ?
-                // If we do so, we risk causing cache MISS even though it has been revalidated elsewhere
-                // On the other hand revalidating a tag that is used in a lot of places will cause a lot of requests
-                if (!_hasBeenRevalidated) {
-                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "boolean" }, _hasBeenRevalidated));
+                const remainingTags = tags.filter((tag) => !cachedValue.some((item) => item.tag === tag));
+                if (remainingTags.length > 0) {
+                    // We need to put the missing tags in the regional cache
+                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags: remainingTags }, stub));
                 }
                 return _hasBeenRevalidated;
             }));
@@ -266,10 +268,7 @@ class ShardedDOTagCache {
             await stub.writeTags(tags, lastModified);
             // Depending on the shards and the tags, deleting from the regional cache will not work for every tag
             // We also need to delete both cache
-            await Promise.all([
-                this.deleteRegionalCache({ doId, tags, type: "boolean" }),
-                this.deleteRegionalCache({ doId, tags, type: "number" }),
-            ]);
+            await Promise.all([this.deleteRegionalCache({ doId, tags })]);
         }
         catch (e) {
             error("Error while writing tags", e);
@@ -293,41 +292,79 @@ class ShardedDOTagCache {
         }
         return this.localCache;
     }
-    getCacheUrlKey(opts) {
-        const { doId, tags, type } = opts;
-        return `http://local.cache/shard/${doId.shardId}?type=${type}&tags=${encodeURIComponent(tags.join(";"))}`;
+    getCacheUrlKey(doId, tag) {
+        return `http://local.cache/shard/${doId.shardId}?tag=${encodeURIComponent(tag)}`;
     }
+    /**
+     * Get the last revalidation time for the tags from the regional cache
+     * If the cache is not enabled, it will return an empty array
+     * @returns An array of objects with the tag and the last revalidation time
+     */
     async getFromRegionalCache(opts) {
         try {
             if (!this.opts.regionalCache)
-                return;
+                return [];
             const cache = await this.getCacheInstance();
             if (!cache)
-                return;
-            return cache.match(this.getCacheUrlKey(opts));
+                return [];
+            const result = await Promise.all(opts.tags.map(async (tag) => {
+                const cachedResponse = await cache.match(this.getCacheUrlKey(opts.doId, tag));
+                if (!cachedResponse)
+                    return null;
+                const cachedText = await cachedResponse.text();
+                try {
+                    return { tag, time: parseInt(cachedText, 10) };
+                }
+                catch (e) {
+                    debugCache("Error while parsing cached value", e);
+                    return null;
+                }
+            }));
+            return result.filter((item) => item !== null);
         }
         catch (e) {
             error("Error while fetching from regional cache", e);
+            return [];
         }
     }
-    async putToRegionalCache(optsKey, value) {
+    async putToRegionalCache(optsKey, stub) {
         if (!this.opts.regionalCache)
             return;
         const cache = await this.getCacheInstance();
         if (!cache)
             return;
         const tags = optsKey.tags;
-        await cache.put(this.getCacheUrlKey(optsKey), new Response(`${value}`, {
-            headers: {
-                "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}`,
-                ...(tags.length > 0
-                    ? {
-                        "cache-tag": tags.join(","),
-                    }
-                    : {}),
-            },
+        const tagsLastRevalidated = await stub.getRevalidationTimes(tags);
+        await Promise.all(tags.map(async (tag) => {
+            let lastRevalidated = tagsLastRevalidated[tag];
+            if (lastRevalidated === undefined) {
+                if (this.opts.regionalCacheDangerouslyPersistMissingTags) {
+                    lastRevalidated = 0; // If the tag is not found, we set it to 0 as it means it has never been revalidated before.
+                }
+                else {
+                    debugCache("Tag not found in revalidation times", { tag, optsKey });
+                    return; // If the tag is not found, we skip it
+                }
+            }
+            const cacheKey = this.getCacheUrlKey(optsKey.doId, tag);
+            debugCache("Putting to regional cache", { cacheKey, lastRevalidated });
+            await cache.put(cacheKey, new Response(lastRevalidated.toString(), {
+                status: 200,
+                headers: {
+                    "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}`,
+                    ...(tags.length > 0
+                        ? {
+                            "cache-tag": tags.join(","),
+                        }
+                        : {}),
+                },
+            }));
         }));
     }
+    /**
+     * Deletes the regional cache for the given tags
+     * This is used to ensure that the cache is cleared when the tags are revalidated
+     */
     async deleteRegionalCache(optsKey) {
         // We never want to crash because of the cache
         try {
@@ -336,7 +373,11 @@ class ShardedDOTagCache {
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            await cache.delete(this.getCacheUrlKey(optsKey));
+            await Promise.all(optsKey.tags.map(async (tag) => {
+                const cacheKey = this.getCacheUrlKey(optsKey.doId, tag);
+                debugCache("Deleting from regional cache", { cacheKey });
+                await cache.delete(cacheKey);
+            }));
         }
         catch (e) {
             debugCache("Error while deleting from regional cache", e);

package/dist/cli/build/build.js

@@ -63,7 +63,7 @@ export async function build(options, config, projectOpts, wranglerConfig) {
     }
     await createServerBundle(options);
     await compileDurableObjects(options);
-    await bundleServer(options);
+    await bundleServer(options, projectOpts);
     if (!projectOpts.skipWranglerConfigCheck) {
         await createWranglerConfigIfNotExistent(projectOpts);
     }

package/dist/cli/build/bundle-server.d.ts

@@ -1,8 +1,9 @@
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ProjectOptions } from "../project-options.js";
 /**
  * Bundle the Open Next server.
  */
-export declare function bundleServer(buildOpts: BuildOptions): Promise<void>;
+export declare function bundleServer(buildOpts: BuildOptions, projectOpts: ProjectOptions): Promise<void>;
 /**
  * This function apply updates to the bundled code.
  */

package/dist/cli/build/bundle-server.js

@@ -39,7 +39,7 @@ const optionalDependencies = [
 /**
  * Bundle the Open Next server.
  */
-export async function bundleServer(buildOpts) {
+export async function bundleServer(buildOpts, projectOpts) {
     copyPackageCliFiles(packageDistDir, buildOpts);
     const { appPath, outputDir, monorepoRoot, debug } = buildOpts;
     const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
@@ -60,9 +60,9 @@ export async function bundleServer(buildOpts) {
         format: "esm",
         target: "esnext",
         // Minify code as much as possible but stay safe by not renaming identifiers
-        minifyWhitespace: !debug,
+        minifyWhitespace: projectOpts.minify && !debug,
         minifyIdentifiers: false,
-        minifySyntax: !debug,
+        minifySyntax: projectOpts.minify && !debug,
         legalComments: "none",
         metafile: true,
         // Next traces files using the default conditions from `nft` (`node`, `require`, `import` and `default`)

package/dist/cli/build/open-next/createServerBundle.js

@@ -154,6 +154,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const isAfter141 = buildHelper.compareSemver(options.nextVersion, ">=", "14.1");
     const isAfter142 = buildHelper.compareSemver(options.nextVersion, ">=", "14.2");
     const isAfter152 = buildHelper.compareSemver(options.nextVersion, ">=", "15.2.0");
+    const isAfter154 = buildHelper.compareSemver(options.nextVersion, ">=", "15.4.0");
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
@@ -164,6 +165,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableRouting ? ["withRouting"] : []),
                 ...(isAfter142 ? ["patchAsyncStorage"] : []),
                 ...(isAfter141 ? ["appendPrefetch"] : []),
+                ...(isAfter154 ? [] : ["setInitialURL"]),
             ],
         }),
         openNextReplacementPlugin({

package/dist/cli/build/patches/plugins/dynamic-requires.js

@@ -37,22 +37,18 @@ function getRequires(idVariable, files, serverDir) {
 export function inlineDynamicRequires(updater, buildOpts) {
     updater.updateContent("inline-node-module-loader", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/module-loader/node-module-loader\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /class NodeModuleLoader {/,
-                callback: async ({ contents }) => patchCode(contents, await getNodeModuleLoaderRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/module-loader/node-module-loader\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /class NodeModuleLoader {/,
+            callback: async ({ contents }) => patchCode(contents, await getNodeModuleLoaderRule(buildOpts)),
         },
     ]);
     updater.updateContent("inline-require-page", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/require\.js$`, { escape: false }),
-                contentFilter: /function requirePage\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRequirePageRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/require\.js$`, { escape: false }),
+            contentFilter: /function requirePage\(/,
+            callback: async ({ contents }) => patchCode(contents, await getRequirePageRule(buildOpts)),
         },
     ]);
     return { name: "inline-dynamic-requires", setup() { } };

package/dist/cli/build/patches/plugins/find-dir.js

@@ -9,11 +9,9 @@ import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 export function inlineFindDir(updater, buildOpts) {
     return updater.updateContent("inline-find-dir", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/lib/find-pages-dir\.js$`, { escape: false }),
-                contentFilter: /function findDir\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/lib/find-pages-dir\.js$`, { escape: false }),
+            contentFilter: /function findDir\(/,
+            callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
         },
     ]);
 }

package/dist/cli/build/patches/plugins/instrumentation.js

@@ -8,31 +8,25 @@ export function patchInstrumentation(updater, buildOpts) {
     const builtInstrumentationPath = getBuiltInstrumentationPath(buildOpts);
     updater.updateContent("patch-instrumentation-next15-4", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/server/lib/router-utils/instrumentation-globals.external\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /getInstrumentationModule\(/,
-                callback: ({ contents }) => patchCode(contents, getNext154Rule(builtInstrumentationPath)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/server/lib/router-utils/instrumentation-globals.external\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /getInstrumentationModule\(/,
+            callback: ({ contents }) => patchCode(contents, getNext154Rule(builtInstrumentationPath)),
         },
     ]);
     updater.updateContent("patch-instrumentation-next15", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /async loadInstrumentationModule\(/,
-                callback: ({ contents }) => patchCode(contents, getNext15Rule(builtInstrumentationPath)),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /async loadInstrumentationModule\(/,
+            callback: ({ contents }) => patchCode(contents, getNext15Rule(builtInstrumentationPath)),
         },
     ]);
     updater.updateContent("patch-instrumentation-next14", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /async prepareImpl\(/,
-                callback: ({ contents }) => patchCode(contents, getNext14Rule(builtInstrumentationPath)),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /async prepareImpl\(/,
+            callback: ({ contents }) => patchCode(contents, getNext14Rule(builtInstrumentationPath)),
         },
     ]);
     return {

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -13,16 +13,14 @@ import { normalizePath } from "../../utils/normalize-path.js";
 export function inlineLoadManifest(updater, buildOpts) {
     return updater.updateContent("inline-load-manifest", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /function loadManifest\(/,
-                callback: async ({ contents }) => {
-                    contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
-                    contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /function loadManifest\(/,
+            callback: async ({ contents }) => {
+                contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
+                contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/next-server.js

@@ -14,21 +14,19 @@ import { normalizePath } from "../../utils/index.js";
 export function patchNextServer(updater, buildOpts) {
     return updater.updateContent("next-server", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /getBuildId\(/,
-                callback: async ({ contents }) => {
-                    const { outputDir } = buildOpts;
-                    contents = patchCode(contents, buildIdRule);
-                    const outputPath = path.join(outputDir, "server-functions/default");
-                    const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
-                    contents = patchCode(contents, createCacheHandlerRule(cacheHandler));
-                    const composableCacheHandler = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
-                    contents = patchCode(contents, createComposableCacheHandlersRule(composableCacheHandler));
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /getBuildId\(/,
+            callback: async ({ contents }) => {
+                const { outputDir } = buildOpts;
+                contents = patchCode(contents, buildIdRule);
+                const outputPath = path.join(outputDir, "server-functions/default");
+                const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
+                contents = patchCode(contents, createCacheHandlerRule(cacheHandler));
+                const composableCacheHandler = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
+                contents = patchCode(contents, createComposableCacheHandlersRule(composableCacheHandler));
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/open-next.js

@@ -12,14 +12,12 @@ export function patchResolveCache(updater, buildOpts) {
     const indexPath = path.relative(buildOpts.appBuildOutputPath, path.join(outputPath, packagePath, `index.mjs`));
     return updater.updateContent("patch-resolve-cache", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(indexPath),
-                contentFilter: /cacheHandlerPath/,
-                callback: async ({ contents }) => {
-                    contents = patchCode(contents, cacheHandlerRule);
-                    contents = patchCode(contents, compositeCacheHandlerRule);
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(indexPath),
+            contentFilter: /cacheHandlerPath/,
+            callback: async ({ contents }) => {
+                contents = patchCode(contents, cacheHandlerRule);
+                contents = patchCode(contents, compositeCacheHandlerRule);
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/patch-depd-deprecations.js

@@ -8,11 +8,9 @@ import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 export function patchDepdDeprecations(updater) {
     return updater.updateContent("patch-depd-deprecations", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /argument fn must be a function/,
-                callback: ({ contents }) => patchCode(contents, rule),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /argument fn must be a function/,
+            callback: ({ contents }) => patchCode(contents, rule),
         },
     ]);
 }

package/dist/cli/build/patches/plugins/require.js

@@ -1,44 +1,42 @@
 export function fixRequire(updater) {
     return updater.updateContent("fix-require", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /.*/,
-                callback: ({ contents }) => {
-                    // `eval(...)` is not supported by workerd.
-                    contents = contents.replaceAll(`eval("require")`, "require");
-                    // `@opentelemetry` has a few issues.
-                    //
-                    // Next.js has the following code in `next/dist/server/lib/trace/tracer.js`:
-                    //
-                    //     try {
-                    //       api = require('@opentelemetry/api');
-                    //     } catch (err) {
-                    //       api = require('next/dist/compiled/@opentelemetry/api');
-                    //     }
-                    //
-                    // The intent is to allow users to install their own version of `@opentelemetry/api`.
-                    //
-                    // The problem is that even when users do not explicitly install `@opentelemetry/api`,
-                    // `require('@opentelemetry/api')` resolves to the package which is a dependency
-                    // of Next.
-                    //
-                    // The second problem is that when Next traces files, it would not copy the `api/build/esm`
-                    // folder (used by the `module` conditions in package.json) it would only copy `api/build/src`.
-                    // This could be solved by updating the next config:
-                    //
-                    //     const nextConfig: NextConfig = {
-                    //       // ...
-                    //       outputFileTracingIncludes: {
-                    //         "*": ["./node_modules/@opentelemetry/api/build/**/*"],
-                    //       },
-                    //     };
-                    //
-                    // We can consider doing that when we want to enable users to install their own version
-                    // of `@opentelemetry/api`. For now we simply use the pre-compiled version.
-                    contents = contents.replace(/require\(.@opentelemetry\/api.\)/g, `require("next/dist/compiled/@opentelemetry/api")`);
-                    return contents;
-                },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /.*/,
+            callback: ({ contents }) => {
+                // `eval(...)` is not supported by workerd.
+                contents = contents.replaceAll(`eval("require")`, "require");
+                // `@opentelemetry` has a few issues.
+                //
+                // Next.js has the following code in `next/dist/server/lib/trace/tracer.js`:
+                //
+                //     try {
+                //       api = require('@opentelemetry/api');
+                //     } catch (err) {
+                //       api = require('next/dist/compiled/@opentelemetry/api');
+                //     }
+                //
+                // The intent is to allow users to install their own version of `@opentelemetry/api`.
+                //
+                // The problem is that even when users do not explicitly install `@opentelemetry/api`,
+                // `require('@opentelemetry/api')` resolves to the package which is a dependency
+                // of Next.
+                //
+                // The second problem is that when Next traces files, it would not copy the `api/build/esm`
+                // folder (used by the `module` conditions in package.json) it would only copy `api/build/src`.
+                // This could be solved by updating the next config:
+                //
+                //     const nextConfig: NextConfig = {
+                //       // ...
+                //       outputFileTracingIncludes: {
+                //         "*": ["./node_modules/@opentelemetry/api/build/**/*"],
+                //       },
+                //     };
+                //
+                // We can consider doing that when we want to enable users to install their own version
+                // of `@opentelemetry/api`. For now we simply use the pre-compiled version.
+                contents = contents.replace(/require\(.@opentelemetry\/api.\)/g, `require("next/dist/compiled/@opentelemetry/api")`);
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/res-revalidate.js

@@ -65,13 +65,11 @@ export const patchResRevalidate = {
     patches: [
         {
             versions: ">=14.2.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(pages-api\.runtime\.prod\.js|node/api-resolver\.js)$`, {
-                    escape: false,
-                }),
-                contentFilter: /\.trustHostHeader/,
-                patchCode: async ({ code }) => patchCode(code, rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(pages-api\.runtime\.prod\.js|node/api-resolver\.js)$`, {
+                escape: false,
+            }),
+            contentFilter: /\.trustHostHeader/,
+            patchCode: async ({ code }) => patchCode(code, rule),
         },
     ],
 };

package/dist/cli/build/patches/plugins/use-cache.js

@@ -28,13 +28,11 @@ export const patchUseCacheIO = {
     patches: [
         {
             versions: ">=15.3.1",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `server/app-render/async-local-storage\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /createSnapshot/,
-                patchCode: async ({ code }) => patchCode(code, rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `server/app-render/async-local-storage\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /createSnapshot/,
+            patchCode: async ({ code }) => patchCode(code, rule),
         },
     ],
 };

package/dist/cli/build/utils/ensure-cf-config.js

@@ -5,6 +5,8 @@ import logger from "@opennextjs/aws/logger.js";
  * @param config OpenNext configuration.
  */
 export function ensureCloudflareConfig(config) {
+    const mwIsMiddlewareExternal = config.middleware?.external === true;
+    const mwConfig = mwIsMiddlewareExternal ? config.middleware : undefined;
     const requirements = {
         // Check for the default function
         dftUseCloudflareWrapper: config.default?.override?.wrapper === "cloudflare-node",
@@ -18,10 +20,10 @@ export function ensureCloudflareConfig(config) {
             config.default?.override?.queue === "direct" ||
             typeof config.default?.override?.queue === "function",
         // Check for the middleware function
-        mwIsMiddlewareExternal: config.middleware?.external === true,
-        mwUseCloudflareWrapper: config.middleware?.override?.wrapper === "cloudflare-edge",
-        mwUseEdgeConverter: config.middleware?.override?.converter === "edge",
-        mwUseFetchProxy: config.middleware?.override?.proxyExternalRequest === "fetch",
+        mwIsMiddlewareExternal,
+        mwUseCloudflareWrapper: mwConfig?.override?.wrapper === "cloudflare-edge",
+        mwUseEdgeConverter: mwConfig?.override?.converter === "edge",
+        mwUseFetchProxy: mwConfig?.override?.proxyExternalRequest === "fetch",
         hasCryptoExternal: config.edgeExternals?.includes("node:crypto"),
     };
     if (config.default?.override?.queue === "direct") {

package/dist/cli/commands/skew-protection.d.ts

@@ -28,10 +28,10 @@ import type { WorkerEnvVar } from "./helpers.js";
  *
  * @param options Build options
  * @param config OpenNext config
- * @param envVars Environment variables
+ * @param workerEnvVars Worker Environment variables (taken from the wrangler config files)
  * @returns Deployment mapping or undefined
  */
-export declare function getDeploymentMapping(options: BuildOptions, config: OpenNextConfig, envVars: WorkerEnvVar): Promise<Record<string, string> | undefined>;
+export declare function getDeploymentMapping(options: BuildOptions, config: OpenNextConfig, workerEnvVars: WorkerEnvVar): Promise<Record<string, string> | undefined>;
 /**
  * Update an existing deployment mapping:
  * - Replace the "current" version with the latest deployed version

package/dist/cli/commands/skew-protection.js

@@ -36,13 +36,17 @@ const MS_PER_DAY = 24 * 3600 * 1000;
  *
  * @param options Build options
  * @param config OpenNext config
- * @param envVars Environment variables
+ * @param workerEnvVars Worker Environment variables (taken from the wrangler config files)
  * @returns Deployment mapping or undefined
  */
-export async function getDeploymentMapping(options, config, envVars) {
+export async function getDeploymentMapping(options, config, workerEnvVars) {
     if (config.cloudflare?.skewProtection?.enabled !== true) {
         return undefined;
     }
+    // Note that `process.env` is spread after `workerEnvVars` since we do want
+    // system environment variables to take precedence over the variables defined
+    // in the wrangler config files
+    const envVars = { ...workerEnvVars, ...process.env };
     const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
     const deploymentId = nextConfig.deploymentId;
     if (!deploymentId) {

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

@@ -26,7 +26,7 @@ export declare function matchLocalPattern(pattern: LocalPattern, url: URL): bool
  * @param buffer The image bytes
  * @returns a content type of undefined for unsupported content
  */
-export declare function detectContentType(buffer: Uint8Array): "image/svg+xml" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/avif" | "image/x-icon" | "image/x-icns" | "image/tiff" | "image/bmp" | undefined;
+export declare function detectContentType(buffer: Uint8Array): "image/svg+xml" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/avif" | "image/x-icon" | "image/x-icns" | "image/tiff" | "image/bmp" | "image/jxl" | "image/heic" | "application/pdf" | "image/jp2" | undefined;
 declare global {
     var __IMAGES_REMOTE_PATTERNS__: RemotePattern[];
     var __IMAGES_LOCAL_PATTERNS__: LocalPattern[];

package/dist/cli/templates/images.js

@@ -65,12 +65,15 @@ export async function fetchImage(fetcher, imageUrl, ctx) {
             contentType = detectContentType(value);
         }
         if (!contentType) {
-            // Fallback to the sanitized upstream header when the type can not be detected
+            // Fallback to upstream header when the type can not be detected
             // https://github.com/vercel/next.js/blob/d76f0b1/packages/next/src/server/image-optimizer.ts#L748
-            const header = imgResponse.headers.get("content-type") ?? "";
-            if (header.startsWith("image/") && !header.includes(",")) {
-                contentType = header;
-            }
+            contentType = imgResponse.headers.get("content-type") ?? "";
+        }
+        // Sanitize the content type:
+        // - Accept images only
+        // - Reject multiple content types
+        if (!contentType.startsWith("image/") || contentType.includes(",")) {
+            contentType = undefined;
         }
         if (contentType && !(contentType === SVG && !__IMAGES_ALLOW_SVG__)) {
             const headers = new Headers(imgResponse.headers);
@@ -126,12 +129,17 @@ const AVIF = "image/avif";
 const WEBP = "image/webp";
 const PNG = "image/png";
 const JPEG = "image/jpeg";
+const JXL = "image/jxl";
+const JP2 = "image/jp2";
+const HEIC = "image/heic";
 const GIF = "image/gif";
 const SVG = "image/svg+xml";
 const ICO = "image/x-icon";
 const ICNS = "image/x-icns";
 const TIFF = "image/tiff";
 const BMP = "image/bmp";
+// pdf will be rejected (not an `image/...` type)
+const PDF = "application/pdf";
 /**
  * Detects the content type by looking at the first few bytes of a file
  *
@@ -174,4 +182,19 @@ export function detectContentType(buffer) {
     if ([0x42, 0x4d].every((b, i) => buffer[i] === b)) {
         return BMP;
     }
+    if ([0xff, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JXL;
+    }
+    if ([0x00, 0x00, 0x00, 0x0c, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JXL;
+    }
+    if ([0, 0, 0, 0, 0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63].every((b, i) => !b || buffer[i] === b)) {
+        return HEIC;
+    }
+    if ([0x25, 0x50, 0x44, 0x46, 0x2d].every((b, i) => buffer[i] === b)) {
+        return PDF;
+    }
+    if ([0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JP2;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "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.0",
+    "@opennextjs/aws": "3.7.2",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",