@opennextjs/aws 3.7.0 → 3.7.2

package/dist/adapters/middleware.js

@@ -7,14 +7,16 @@ import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL,
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
-    const config = globalThis.openNextConfig.middleware;
-    const originResolver = await resolveOriginResolver(config?.originResolver);
-    const externalRequestProxy = await resolveProxyRequest(config?.override?.proxyExternalRequest);
-    const assetResolver = await resolveAssetResolver(config?.assetResolver);
+    // We know that the middleware is external when this adapter is used
+    const middlewareConfig = globalThis.openNextConfig
+        .middleware;
+    const originResolver = await resolveOriginResolver(middlewareConfig?.originResolver);
+    const externalRequestProxy = await resolveProxyRequest(middlewareConfig?.override?.proxyExternalRequest);
+    const assetResolver = await resolveAssetResolver(middlewareConfig?.assetResolver);
     //#override includeCacheInMiddleware
-    globalThis.tagCache = await resolveTagCache(config?.override?.tagCache);
-    globalThis.queue = await resolveQueue(config?.override?.queue);
-    globalThis.incrementalCache = await resolveIncrementalCache(config?.override?.incrementalCache);
+    globalThis.tagCache = await resolveTagCache(middlewareConfig?.override?.tagCache);
+    globalThis.queue = await resolveQueue(middlewareConfig?.override?.queue);
+    globalThis.incrementalCache = await resolveIncrementalCache(middlewareConfig?.override?.incrementalCache);
     //#endOverride
     const requestId = Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the external middleware

package/dist/build/createServerBundle.js

@@ -139,6 +139,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 updater = new ContentUpdater(options);
     const additionalPlugins = codeCustomization?.additionalPlugins
@@ -153,6 +154,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableRouting ? ["withRouting"] : []),
                 ...(isAfter142 ? ["patchAsyncStorage"] : []),
                 ...(isAfter141 ? ["appendPrefetch"] : []),
+                ...(isAfter154 ? [] : ["setInitialURL"]),
             ],
         }),
         openNextReplacementPlugin({

package/dist/build/generateOutput.js

@@ -61,11 +61,13 @@ export async function generateOutput(options) {
     const edgeFunctions = {};
     const isExternalMiddleware = config.middleware?.external ?? false;
     if (isExternalMiddleware) {
+        const middlewareConfig = options.config
+            .middleware;
         edgeFunctions.middleware = {
             bundle: ".open-next/middleware",
             handler: "handler.handler",
-            pathResolver: await extractOverrideName("pattern-env", config.middleware.originResolver),
-            ...(await extractOverrideFn(config.middleware?.override)),
+            pathResolver: await extractOverrideName("pattern-env", middlewareConfig.originResolver),
+            ...(await extractOverrideFn(middlewareConfig.override)),
         };
     }
     // Add edge functions

package/dist/build/installDeps.js

@@ -35,6 +35,28 @@ export function installDependencies(outputDir, installOptions) {
         });
         // Copy the node_modules to the outputDir
         fs.cpSync(path.join(tempInstallDir, "node_modules"), path.join(outputDir, "node_modules"), { recursive: true, force: true, dereference: true });
+        // This is a workaround for Node `22.17.0` and `22.17.1`
+        // https://github.com/nodejs/node/issues/59168
+        const nodeVersion = process.version;
+        if (nodeVersion === "v22.17.0" || nodeVersion === "v22.17.1") {
+            const tempBinDir = path.join(tempInstallDir, "node_modules", ".bin");
+            const outputBinDir = path.join(outputDir, "node_modules", ".bin");
+            for (const fileName of fs.readdirSync(tempBinDir)) {
+                const symlinkPath = path.join(tempBinDir, fileName);
+                const stat = fs.lstatSync(symlinkPath);
+                if (stat.isSymbolicLink()) {
+                    const linkTarget = fs.readlinkSync(symlinkPath);
+                    const realFilePath = path.resolve(tempBinDir, linkTarget);
+                    const outputFilePath = path.join(outputBinDir, fileName);
+                    if (fs.existsSync(outputFilePath)) {
+                        fs.unlinkSync(outputFilePath);
+                    }
+                    fs.copyFileSync(realFilePath, outputFilePath);
+                    fs.chmodSync(outputFilePath, "755");
+                    logger.debug(`Replaced symlink ${fileName} with actual file`);
+                }
+            }
+        }
         // Cleanup tempDir
         fs.rmSync(tempInstallDir, { recursive: true, force: true });
         logger.info(`Dependencies installed for ${name}`);

package/dist/build/patch/codePatcher.d.ts

@@ -1,15 +1,14 @@
 import type { getManifests } from "../copyTracedFiles.js";
 import * as buildHelper from "../helper.js";
-type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
-export interface VersionedField<T> {
-    /**
-     * The versions of Next.js that this field should be used for
-     * Should be in the format `">=16.0.0 <=17.0.0"` or `">=16.0.0"` or `"<=17.0.0"`
-     * **Be careful with spaces**
-     */
-    versions?: Versions;
-    field: T;
-}
+/**
+ * Accepted formats:
+ * - `">=16.0.0"`
+ * - `"<=16.0.0"`
+ * - `">=16.0.0 <=17.0.0"`
+ *
+ * **Be careful with spaces**
+ */
+export type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
 export type PatchCodeFn = (args: {
     /**
      * The code of the file that needs to be patched
@@ -32,15 +31,23 @@ interface IndividualPatch {
     pathFilter: RegExp;
     contentFilter?: RegExp;
     patchCode: PatchCodeFn;
+    versions?: Versions;
 }
 export interface CodePatcher {
     name: string;
-    patches: IndividualPatch | VersionedField<IndividualPatch>[];
+    patches: IndividualPatch[];
 }
 export declare function parseVersions(versions?: Versions): {
     before?: string;
     after?: string;
 };
-export declare function extractVersionedField<T>(fields: VersionedField<T>[], version: string): T[];
+/**
+ * Check whether the version is in the range
+ *
+ * @param version A semver version
+ * @param versionRange A version range
+ * @returns whether the version satisfies the range
+ */
+export declare function isVersionInRange(version: string, versionRange?: Versions): boolean;
 export declare function applyCodePatches(buildOptions: buildHelper.BuildOptions, tracedFiles: string[], manifests: ReturnType<typeof getManifests>, codePatcher: CodePatcher[]): Promise<void>;
 export {};

package/dist/build/patch/codePatcher.js

@@ -39,50 +39,33 @@ export function parseVersions(versions) {
         after,
     };
 }
-export function extractVersionedField(fields, version) {
-    const result = [];
-    for (const field of fields) {
-        // No versions specified, the patch always apply
-        if (!field.versions) {
-            result.push(field.field);
-            continue;
-        }
-        const { before, after } = parseVersions(field.versions);
-        // range
-        if (before && after) {
-            if (buildHelper.compareSemver(version, "<=", before) &&
-                buildHelper.compareSemver(version, ">=", after)) {
-                result.push(field.field);
-            }
-            continue;
-        }
-        // before only
-        if (before) {
-            if (buildHelper.compareSemver(version, "<=", before)) {
-                result.push(field.field);
-            }
-            continue;
-        }
-        // after only
-        if (after) {
-            if (buildHelper.compareSemver(version, ">=", after)) {
-                result.push(field.field);
-            }
-        }
+/**
+ * Check whether the version is in the range
+ *
+ * @param version A semver version
+ * @param versionRange A version range
+ * @returns whether the version satisfies the range
+ */
+export function isVersionInRange(version, versionRange) {
+    const { before, after } = parseVersions(versionRange);
+    let inRange = true;
+    if (before) {
+        inRange &&= buildHelper.compareSemver(version, "<=", before);
+    }
+    if (after) {
+        inRange &&= buildHelper.compareSemver(version, ">=", after);
     }
-    return result;
+    return inRange;
 }
 export async function applyCodePatches(buildOptions, tracedFiles, manifests, codePatcher) {
-    const nextVersion = buildOptions.nextVersion;
     logger.time("Applying code patches");
     // We first filter against the version
     // We also flatten the array of patches so that we get both the name and all the necessary patches
-    const patchesToApply = codePatcher.flatMap(({ name, patches }) => Array.isArray(patches)
-        ? extractVersionedField(patches, nextVersion).map((patch) => ({
-            name,
-            patch,
-        }))
-        : [{ name, patch: patches }]);
+    const patchesToApply = codePatcher.flatMap(({ name, patches }) => {
+        return patches
+            .filter(({ versions }) => isVersionInRange(buildOptions.nextVersion, versions))
+            .map((patch) => ({ patch, name }));
+    });
     await Promise.all(tracedFiles.map(async (filePath) => {
         // We check the filename against the filter to see if we should apply the patch
         const patchMatchingPath = patchesToApply.filter(({ patch }) => {

package/dist/build/patch/patches/patchBackgroundRevalidation.d.ts

@@ -3,9 +3,7 @@ export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {
         versions: ">=14.1.0";
-        field: {
-            pathFilter: RegExp;
-            patchCode: import("../codePatcher.js").PatchCodeFn;
-        };
+        pathFilter: RegExp;
+        patchCode: import("../codePatcher.js").PatchCodeFn;
     }[];
 };

package/dist/build/patch/patches/patchBackgroundRevalidation.js

@@ -18,10 +18,8 @@ export const patchBackgroundRevalidation = {
         {
             // TODO: test for earlier versions of Next
             versions: ">=14.1.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
-                patchCode: createPatchCode(rule),
-            },
+            pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+            patchCode: createPatchCode(rule),
         },
     ],
 };

package/dist/build/patch/patches/patchEnvVar.js

@@ -24,29 +24,23 @@ export const patchEnvVars = {
         // This patch will set the `NEXT_RUNTIME` env var to "node" to avoid loading unnecessary edge deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /module\.compiled\.js$/,
-                contentFilter: /process\.env\.NEXT_RUNTIME/,
-                patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
-            },
+            pathFilter: /module\.compiled\.js$/,
+            contentFilter: /process\.env\.NEXT_RUNTIME/,
+            patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
         },
         // This patch will set `NODE_ENV` to production to avoid loading unnecessary dev deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
-                contentFilter: /process\.env\.NODE_ENV/,
-                patchCode: createPatchCode(envVarRuleCreator("NODE_ENV", '"production"')),
-            },
+            pathFilter: /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
+            contentFilter: /process\.env\.NODE_ENV/,
+            patchCode: createPatchCode(envVarRuleCreator("NODE_ENV", '"production"')),
         },
         // This patch will set `TURBOPACK` env to false to avoid loading turbopack related deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /module\.compiled\.js$/,
-                contentFilter: /process\.env\.TURBOPACK/,
-                patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
-            },
+            pathFilter: /module\.compiled\.js$/,
+            contentFilter: /process\.env\.TURBOPACK/,
+            patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
         },
     ],
 };

package/dist/build/patch/patches/patchFetchCacheISR.d.ts

@@ -1,7 +1,7 @@
 import type { CodePatcher } from "../codePatcher.js";
-export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
-export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
-export declare const useCacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: binary_expression\n    has: \n      kind: member_expression\n      pattern: $STORE_OR_CACHE.isDraftMode\n    inside:\n      kind: if_statement\n      stopBy: end\n      has: \n        kind: return_statement\n        any:\n          - has:\n              kind: 'true'\n          - has:\n              regex: '!0'\n        stopBy: end\nfix:\n  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'";
+export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has:\n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has:\n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const useCacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: binary_expression\n    has:\n      kind: member_expression\n      pattern: $STORE_OR_CACHE.isDraftMode\n    inside:\n      kind: if_statement\n      stopBy: end\n      has:\n        kind: return_statement\n        any:\n          - has:\n              kind: 'true'\n          - has:\n              regex: '!0'\n        stopBy: end\nfix:\n  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'";
 export declare const patchFetchCacheForISR: CodePatcher;
 export declare const patchUnstableCacheForISR: CodePatcher;
 export declare const patchUseCacheForISR: CodePatcher;

package/dist/build/patch/patches/patchFetchCacheISR.js

@@ -9,7 +9,7 @@ rule:
     kind: ternary_expression
     all:
       - has: {kind: 'null'}
-      - has: 
+      - has:
           kind: await_expression
           has:
             kind: call_expression
@@ -48,7 +48,7 @@ rule:
       kind: statement_block
       has:
         kind: variable_declarator
-        has: 
+        has:
           kind: await_expression
           has:
             kind: call_expression
@@ -80,13 +80,13 @@ rule:
   pattern: $STORE_OR_CACHE.isOnDemandRevalidate
   inside:
     kind: binary_expression
-    has: 
+    has:
       kind: member_expression
       pattern: $STORE_OR_CACHE.isDraftMode
     inside:
       kind: if_statement
       stopBy: end
-      has: 
+      has:
         kind: return_statement
         any:
           - has:
@@ -101,11 +101,9 @@ export const patchFetchCacheForISR = {
     patches: [
         {
             versions: ">=14.0.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(fetchRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(fetchRule, Lang.JavaScript),
         },
     ],
 };
@@ -114,11 +112,9 @@ export const patchUnstableCacheForISR = {
     patches: [
         {
             versions: ">=14.2.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
         },
     ],
 };
@@ -127,11 +123,9 @@ export const patchUseCacheForISR = {
     patches: [
         {
             versions: ">=15.3.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|\.runtime\..*\.js|use-cache/use-cache-wrapper\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(useCacheRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|\.runtime\..*\.js|use-cache/use-cache-wrapper\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(useCacheRule, Lang.JavaScript),
         },
     ],
 };

package/dist/build/patch/patches/patchFetchCacheWaitUntil.js

@@ -26,11 +26,9 @@ export const patchFetchCacheSetMissingWaitUntil = {
     patches: [
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
-                contentFilter: /arrayBuffer\(\)\s*\.then/,
-                patchCode: createPatchCode(rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+            contentFilter: /arrayBuffer\(\)\s*\.then/,
+            patchCode: createPatchCode(rule),
         },
     ],
 };

package/dist/build/patch/patches/patchNextServer.js

@@ -71,27 +71,21 @@ const pathFilter = getCrossPlatformPathRegex(String.raw `/next/dist/server/next-
 const babelPatches = [
     // Empty the body of `NextServer#runMiddleware`
     {
-        field: {
-            pathFilter,
-            contentFilter: /runMiddleware\(/,
-            patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
-        },
+        pathFilter,
+        contentFilter: /runMiddleware\(/,
+        patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
     },
     // Empty the body of `NextServer#runEdgeFunction`
     {
-        field: {
-            pathFilter,
-            contentFilter: /runEdgeFunction\(/,
-            patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
-        },
+        pathFilter,
+        contentFilter: /runEdgeFunction\(/,
+        patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
     },
     // Drop `error-inspect` that pulls babel
     {
-        field: {
-            pathFilter,
-            contentFilter: /error-inspect/,
-            patchCode: createPatchCode(errorInspectRule),
-        },
+        pathFilter,
+        contentFilter: /error-inspect/,
+        patchCode: createPatchCode(errorInspectRule),
     },
 ];
 export const patchNextServer = {
@@ -99,30 +93,24 @@ export const patchNextServer = {
     patches: [
         // Empty the body of `NextServer#imageOptimizer` - unused in OpenNext
         {
-            field: {
-                pathFilter,
-                contentFilter: /imageOptimizer\(/,
-                patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
-            },
+            pathFilter,
+            contentFilter: /imageOptimizer\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
         },
         // Disable Next background preloading done at creation of `NextServer`
         {
             versions: ">=14.0.0",
-            field: {
-                pathFilter,
-                contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
-                patchCode: createPatchCode(disablePreloadingRule),
-            },
+            pathFilter,
+            contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
+            patchCode: createPatchCode(disablePreloadingRule),
         },
         // Don't match edge functions in `NextServer`
         {
             // Next 12 and some version of 13 use the bundled middleware/edge function
             versions: ">=14.0.0",
-            field: {
-                pathFilter,
-                contentFilter: /getMiddlewareManifest/,
-                patchCode: createPatchCode(removeMiddlewareManifestRule),
-            },
+            pathFilter,
+            contentFilter: /getMiddlewareManifest/,
+            patchCode: createPatchCode(removeMiddlewareManifestRule),
         },
         ...babelPatches,
     ],

package/dist/build/validateConfig.js

@@ -72,7 +72,9 @@ export function validateConfig(config) {
        It is safe to disable if you only use page router`);
     }
     validateFunctionOptions(config.imageOptimization ?? {});
-    validateFunctionOptions(config.middleware ?? {});
+    if (config.middleware?.external === true) {
+        validateFunctionOptions(config.middleware ?? {});
+    }
     //@ts-expect-error - Revalidate custom wrapper type is different
     validateFunctionOptions(config.revalidate ?? {});
     //@ts-expect-error - Warmer custom wrapper type is different

package/dist/core/createGenericHandler.js

@@ -4,8 +4,10 @@ export async function createGenericHandler(handler) {
     // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
     globalThis.openNextConfig = config;
-    const override = config[handler.type]
-        ?.override;
+    const handlerConfig = config[handler.type];
+    const override = handlerConfig && "override" in handlerConfig
+        ? handlerConfig.override
+        : undefined;
     // From the config, we create the converter
     const converter = await resolveConverter(override?.converter);
     // Then we create the handler

package/dist/core/requestHandler.js

@@ -4,7 +4,7 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
+import { constructNextUrl, convertRes, convertToQuery, convertToQueryString, createServerResponse, } from "./routing/util";
 import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
@@ -167,7 +167,10 @@ async function processRequest(req, res, routingResult) {
     // Here we try to apply as much request metadata as possible
     // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-utils/resolve-routes.ts
     // and `router-server` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-server.ts
-    const initialURL = new URL(routingResult.initialURL);
+    const initialURL = new URL(
+    // We always assume that only the routing layer can set this header.
+    routingResult.internalEvent.headers[INTERNAL_HEADER_INITIAL_URL] ??
+        routingResult.initialURL);
     let invokeStatus;
     if (routingResult.internalEvent.rawPath === "/500") {
         invokeStatus = 500;
@@ -194,6 +197,13 @@ async function processRequest(req, res, routingResult) {
         setNextjsPrebundledReact(routingResult.internalEvent.rawPath);
         //#endOverride
         // Next Server
+        // TODO: only enable this on Next 15.4+
+        // We need to set the pathname to the data request path
+        //#override setInitialURL
+        req.url =
+            initialURL.pathname +
+                convertToQueryString(routingResult.internalEvent.query);
+        //#endOverride
         await requestHandler(requestMetadata)(req, res);
     }
     catch (e) {
@@ -253,6 +263,7 @@ async function tryRenderError(type, res, internalEvent) {
     }
     catch (e) {
         error("NextJS request failed.", e);
+        res.statusCode = 500;
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify({
             message: "Server failed to respond.",

package/dist/core/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { BaseEventOrResult, DefaultOverrideOptions, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
+import type { BaseEventOrResult, DefaultOverrideOptions, ExternalMiddlewareConfig, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
 import type { Converter, TagCache, Wrapper } from "../types/overrides";
 type RemoveUndefined<T> = T extends undefined ? never : T;
 export declare function resolveConverter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(converter: DefaultOverrideOptions<E, R>["converter"]): Promise<Converter<E, R>>;
@@ -34,7 +34,7 @@ export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNext
  * @returns
  * @__PURE__
  */
-export declare function resolveOriginResolver(originResolver: RemoveUndefined<OpenNextConfig["middleware"]>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
+export declare function resolveOriginResolver(originResolver: RemoveUndefined<ExternalMiddlewareConfig>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
 /**
  * @returns
  * @__PURE__

package/dist/core/routing/cacheInterceptor.js

@@ -144,6 +144,14 @@ export async function cacheInterceptor(event) {
     if (Boolean(event.headers["next-action"]) ||
         Boolean(event.headers["x-prerender-revalidate"]))
         return event;
+    // Check for Next.js preview mode cookies
+    const cookies = event.headers.cookie || "";
+    const hasPreviewData = cookies.includes("__prerender_bypass") ||
+        cookies.includes("__next_preview_data");
+    if (hasPreviewData) {
+        debug("Preview mode detected, passing through to handler");
+        return event;
+    }
     // We localize the path in case i18n is enabled
     let localizedPath = localizePath(event);
     // If using basePath we need to remove it from the path

package/dist/plugins/content-updater.d.ts

@@ -5,7 +5,7 @@
  */
 import type { OnLoadOptions, Plugin, PluginBuild } from "esbuild";
 import type { BuildOptions } from "../build/helper";
-import { type VersionedField } from "../build/patch/codePatcher.js";
+import { type Versions } from "../build/patch/codePatcher.js";
 export type * from "esbuild";
 /**
  * The callbacks returns either an updated content or undefined if the content is unchanged.
@@ -23,6 +23,7 @@ export type OnUpdateOptions = OnLoadOptions & {
 };
 export type Updater = OnUpdateOptions & {
     callback: Callback;
+    versions?: Versions;
 };
 export declare class ContentUpdater {
     private buildOptions;
@@ -34,10 +35,10 @@ export declare class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @param updaters A list of code updaters
      * @returns A noop ESBuild plugin.
      */
-    updateContent(name: string, versionedUpdaters: VersionedField<Updater>[]): Plugin;
+    updateContent(name: string, updaters: Updater[]): Plugin;
     /**
      * Returns an ESBuild plugin applying the registered updates.
      */

package/dist/plugins/content-updater.js

@@ -4,7 +4,7 @@
  * The updater allows multiple plugins to update the content.
  */
 import { readFile } from "node:fs/promises";
-import { extractVersionedField, } from "../build/patch/codePatcher.js";
+import { isVersionInRange } from "../build/patch/codePatcher.js";
 export class ContentUpdater {
     buildOptions;
     updaters = new Map();
@@ -17,15 +17,14 @@ export class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @param updaters A list of code updaters
      * @returns A noop ESBuild plugin.
      */
-    updateContent(name, versionedUpdaters) {
+    updateContent(name, updaters) {
         if (this.updaters.has(name)) {
             throw new Error(`Plugin "${name}" already registered`);
         }
-        const updaters = extractVersionedField(versionedUpdaters, this.buildOptions.nextVersion);
-        this.updaters.set(name, updaters);
+        this.updaters.set(name, updaters.filter(({ versions }) => isVersionInRange(this.buildOptions.nextVersion, versions)));
         return {
             name,
             setup() { },

package/dist/types/open-next.d.ts

@@ -244,43 +244,56 @@ export interface SplittedFunctionOptions extends FunctionOptions {
      */
     patterns: string[];
 }
+/**
+ * MiddlewareConfig that applies to both external and internal middlewares
+ *
+ * Note: this type is internal and included in both `ExternalMiddlewareConfig` and `InternalMiddlewareConfig`
+ */
+type CommonMiddlewareConfig = {
+    /**
+     * The assetResolver is used to resolve assets in the routing layer.
+     *
+     * @default "dummy"
+     */
+    assetResolver?: IncludedAssetResolver | LazyLoadedOverride<AssetResolver>;
+};
+/** MiddlewareConfig that applies to external middlewares only */
+export type ExternalMiddlewareConfig = DefaultFunctionOptions & CommonMiddlewareConfig & {
+    external: true;
+    /**
+     * The runtime used by next for the middleware.
+     * @default "edge"
+     */
+    runtime?: "node" | "edge";
+    /**
+     * The override options for the middleware.
+     * By default the lite override are used (.i.e. s3-lite, dynamodb-lite, sqs-lite)
+     * @default undefined
+     */
+    override?: OverrideOptions;
+    /**
+     * Origin resolver is used to resolve the origin for internal rewrite.
+     * By default, it uses the pattern-env origin resolver.
+     * Pattern env uses pattern set in split function options and an env variable OPEN_NEXT_ORIGIN
+     * OPEN_NEXT_ORIGIN should be a json stringified object with the key of the splitted function as key and the origin as value
+     * @default "pattern-env"
+     */
+    originResolver?: IncludedOriginResolver | LazyLoadedOverride<OriginResolver>;
+};
+/** MiddlewareConfig that applies to internal middlewares only */
+export type InternalMiddlewareConfig = {
+    external: false;
+} & CommonMiddlewareConfig;
 export interface OpenNextConfig {
     default: FunctionOptions;
     functions?: Record<string, SplittedFunctionOptions>;
     /**
      * Override the default middleware
-     * If you set this options, the middleware need to be deployed separately.
+     * When `external` is true, the middleware need to be deployed separately.
      * It supports both edge and node runtime.
-     * @default undefined
+     * @default undefined - Which is equivalent to `external: false`
      */
-    middleware?: DefaultFunctionOptions & {
-        external: true;
-        /**
-         * The runtime used by next for the middleware.
-         * @default "edge"
-         */
-        runtime?: "node" | "edge";
-        /**
-         * The override options for the middleware.
-         * By default the lite override are used (.i.e. s3-lite, dynamodb-lite, sqs-lite)
-         * @default undefined
-         */
-        override?: OverrideOptions;
-        /**
-         * Origin resolver is used to resolve the origin for internal rewrite.
-         * By default, it uses the pattern-env origin resolver.
-         * Pattern env uses pattern set in split function options and an env variable OPEN_NEXT_ORIGIN
-         * OPEN_NEXT_ORIGIN should be a json stringified object with the key of the splitted function as key and the origin as value
-         * @default "pattern-env"
-         */
-        originResolver?: IncludedOriginResolver | LazyLoadedOverride<OriginResolver>;
-        /**
-         * The assetResolver is used to resolve assets in the routing layer.
-         *
-         * @default "dummy"
-         */
-        assetResolver?: IncludedAssetResolver | LazyLoadedOverride<AssetResolver>;
-    };
+    middleware?: ExternalMiddlewareConfig | InternalMiddlewareConfig;
     /**
      * Override the default warmer
      * By default, works for lambda only.
@@ -362,3 +375,4 @@ export interface OpenNextConfig {
      */
     edgeExternals?: string[];
 }
+export {};

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.7.0",
+  "version": "3.7.2",
   "bin": {
     "open-next": "./dist/index.js"
   },