@opennextjs/aws 3.5.5 → 3.5.7

package/dist/build/createAssets.d.ts

@@ -1,6 +1,16 @@
 import type { TagCacheMetaFile } from "../types/cache.js";
 import * as buildHelper from "./helper.js";
-export declare function createStaticAssets(options: buildHelper.BuildOptions): void;
+/**
+ * Copy the static assets to the output folder
+ *
+ * WARNING: `useBasePath` should be set to `false` when the output file is used.
+ *
+ * @param options OpenNext build options
+ * @param useBasePath whether to copy files into the to Next.js configured basePath
+ */
+export declare function createStaticAssets(options: buildHelper.BuildOptions, { useBasePath }?: {
+    useBasePath?: boolean | undefined;
+}): void;
 /**
  * Create the cache assets.
  *

package/dist/build/createAssets.js

@@ -1,16 +1,31 @@
 import fs from "node:fs";
 import path from "node:path";
+import { loadConfig } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
 import * as buildHelper from "./helper.js";
-export function createStaticAssets(options) {
+/**
+ * Copy the static assets to the output folder
+ *
+ * WARNING: `useBasePath` should be set to `false` when the output file is used.
+ *
+ * @param options OpenNext build options
+ * @param useBasePath whether to copy files into the to Next.js configured basePath
+ */
+export function createStaticAssets(options, { useBasePath = false } = {}) {
     logger.info("Bundling static assets...");
     const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
+    const NextConfig = loadConfig(path.join(appBuildOutputPath, ".next"));
+    const basePath = useBasePath ? (NextConfig.basePath ?? "") : "";
     // Create output folder
-    const outputPath = path.join(outputDir, "assets");
+    const outputPath = path.join(outputDir, "assets", basePath);
     fs.mkdirSync(outputPath, { recursive: true });
     /**
-     * Next.js outputs assets into multiple files. Copy into the same directory.
+     * Next.js outputs assets into multiple files.
+     *
+     * Copy into the same directory:
+     * - `.open-next/assets` when `useBasePath` is `false`
+     * - `.open-next/assets/basePath` when `useBasePath` is `true`
      *
      * Copy over:
      * - .next/BUILD_ID => BUILD_ID

package/dist/build/createServerBundle.js

@@ -14,8 +14,8 @@ import { copyMiddlewareResources, generateEdgeBundle, } from "./edge/createEdgeB
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { applyCodePatches } from "./patch/codePatcher.js";
-import { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patch/patchFetchCacheISR.js";
-import { patchFetchCacheSetMissingWaitUntil } from "./patch/patchFetchCacheWaitUntil.js";
+import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "./patch/patches/index.js";
+import { patchBackgroundRevalidation } from "./patch/patches/patchBackgroundRevalidation.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -120,6 +120,9 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchFetchCacheSetMissingWaitUntil,
         patchFetchCacheForISR,
         patchUnstableCacheForISR,
+        patchNextServer,
+        patchEnvVars,
+        patchBackgroundRevalidation,
         ...additionalCodePatches,
     ]);
     // Build Lambda code
@@ -145,6 +148,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
                 ...(isAfter142 ? ["patchAsyncStorage"] : []),
+                ...(isAfter141 ? ["appendPrefetch"] : []),
             ],
         }),
         openNextReplacementPlugin({

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

@@ -0,0 +1,4 @@
+export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
+export { patchNextServer } from "./patchNextServer.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";

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

@@ -0,0 +1,4 @@
+export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
+export { patchNextServer } from "./patchNextServer.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";

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

@@ -0,0 +1,11 @@
+export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        regex: \"!cachedResponse.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const patchBackgroundRevalidation: {
+    name: string;
+    patches: {
+        versions: ">=14.1.0";
+        field: {
+            pathFilter: RegExp;
+            patchCode: import("../codePatcher.js").PatchCodeFn;
+        };
+    }[];
+};

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

@@ -0,0 +1,27 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
+export const rule = `
+rule:
+  kind: binary_expression
+  all:
+    - has:
+        kind: unary_expression
+        regex: "!cachedResponse.isStale"
+    -  has:
+         kind: member_expression
+         regex: "context.isPrefetch"
+fix:
+  'true'`;
+export const patchBackgroundRevalidation = {
+    name: "patchBackgroundRevalidation",
+    patches: [
+        {
+            // TODO: test for earlier versions of Next
+            versions: ">=14.1.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+                patchCode: createPatchCode(rule),
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,10 @@
+import type { CodePatcher } from "../codePatcher";
+/**
+ * Creates a rule to replace `process.env.${envVar}` by `value` in the condition of if statements
+ * This is used to avoid loading unnecessary deps at runtime
+ * @param envVar The env var that we want to replace
+ * @param value The value that we want to replace it with
+ * @returns
+ */
+export declare const envVarRuleCreator: (envVar: string, value: string) => string;
+export declare const patchEnvVars: CodePatcher;

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

@@ -0,0 +1,52 @@
+import { createPatchCode } from "../astCodePatcher.js";
+/**
+ * Creates a rule to replace `process.env.${envVar}` by `value` in the condition of if statements
+ * This is used to avoid loading unnecessary deps at runtime
+ * @param envVar The env var that we want to replace
+ * @param value The value that we want to replace it with
+ * @returns
+ */
+export const envVarRuleCreator = (envVar, value) => `
+rule:
+  kind: member_expression
+  pattern: process.env.${envVar}
+  inside:
+    kind: parenthesized_expression
+    stopBy: end
+    inside:
+      kind: if_statement
+fix:
+  '${value}'
+`;
+export const patchEnvVars = {
+    name: "patch-env-vars",
+    patches: [
+        // 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"')),
+            },
+        },
+        // 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"')),
+            },
+        },
+        // 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")),
+            },
+        },
+    ],
+};

package/dist/build/patch/{patchFetchCacheISR.d.ts → patches/patchFetchCacheISR.d.ts}

@@ -1,4 +1,4 @@
-import type { CodePatcher } from "./codePatcher";
+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 patchFetchCacheForISR: CodePatcher;

package/dist/build/patch/{patchFetchCacheISR.js → patches/patchFetchCacheISR.js}

@@ -1,6 +1,6 @@
 import { Lang } from "@ast-grep/napi";
-import { getCrossPlatformPathRegex } from "../../utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
 export const fetchRule = `
 rule:
   kind: member_expression

package/dist/build/patch/{patchFetchCacheWaitUntil.d.ts → patches/patchFetchCacheWaitUntil.d.ts}

@@ -1,3 +1,3 @@
-import type { CodePatcher } from "./codePatcher";
+import type { CodePatcher } from "../codePatcher.js";
 export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    - has: { pattern: $_.arrayBuffer().then, stopBy: end }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - any:\n        - inside:\n            kind: sequence_expression\n            inside:\n                kind: return_statement\n        - inside:\n            kind: expression_statement\n            precedes:\n                kind: return_statement\n    - has: { pattern: $_.FETCH, stopBy: end }\n\nfix: |\n  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)\n";
 export declare const patchFetchCacheSetMissingWaitUntil: CodePatcher;

package/dist/build/patch/{patchFetchCacheWaitUntil.js → patches/patchFetchCacheWaitUntil.js}

@@ -1,5 +1,5 @@
-import { getCrossPlatformPathRegex } from "../../utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
 export const rule = `
 rule:
   kind: call_expression

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

@@ -0,0 +1,5 @@
+import type { CodePatcher } from "../codePatcher.js";
+export declare const minimalRule = "\nrule:\n  kind: member_expression\n  pattern: process.env.NEXT_MINIMAL\n  any:\n    - inside:\n        kind: parenthesized_expression\n        stopBy: end\n        inside:\n          kind: if_statement\n          any:\n            - inside:\n                kind: statement_block\n                inside:\n                  kind: method_definition\n                  any:\n                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}\n                    - has: {kind: property_identifier, field: name, regex: runMiddleware}\n                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}\n            - has:\n                kind: statement_block\n                has:\n                  kind: expression_statement\n                  pattern: res.statusCode = 400;\nfix:\n  'true'\n";
+export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any: \n      - has: \n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has: \n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
+export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: getMiddlewareManifest\nfix:\n  '{return null;}'\n";
+export declare const patchNextServer: CodePatcher;

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

@@ -0,0 +1,91 @@
+import { createPatchCode } from "../astCodePatcher.js";
+// This rule will replace the `NEXT_MINIMAL` env variable with true in multiple places to avoid executing unwanted path (i.e. next middleware, edge functions and image optimization)
+export const minimalRule = `
+rule:
+  kind: member_expression
+  pattern: process.env.NEXT_MINIMAL
+  any:
+    - inside:
+        kind: parenthesized_expression
+        stopBy: end
+        inside:
+          kind: if_statement
+          any:
+            - inside:
+                kind: statement_block
+                inside:
+                  kind: method_definition
+                  any:
+                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}
+                    - has: {kind: property_identifier, field: name, regex: runMiddleware}
+                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}
+            - has:
+                kind: statement_block
+                has:
+                  kind: expression_statement
+                  pattern: res.statusCode = 400;
+fix:
+  'true'
+`;
+// This rule will disable the background preloading of route done by NextServer by default during the creation of NextServer
+export const disablePreloadingRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: if_statement
+    any: 
+      - has: 
+          kind: member_expression
+          pattern: this.nextConfig.experimental.preloadEntriesOnStart
+          stopBy: end
+      - has: 
+          kind: binary_expression
+          pattern: appDocumentPreloading === true
+          stopBy: end
+fix:
+  '{}'
+`;
+// This rule is mostly for splitted edge functions so that we don't try to match them on the other non edge functions
+export const removeMiddlewareManifestRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: method_definition
+    has:
+      kind: property_identifier
+      regex: getMiddlewareManifest
+fix:
+  '{return null;}'
+`;
+export const patchNextServer = {
+    name: "patch-next-server",
+    patches: [
+        // Skip executing next middleware, edge functions and image optimization inside NextServer
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /process\.env\.NEXT_MINIMAL/,
+                patchCode: createPatchCode(minimalRule),
+            },
+        },
+        // Disable Next background preloading done at creation of `NetxServer`
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
+                patchCode: createPatchCode(disablePreloadingRule),
+            },
+        },
+        // Don't match edge functions in `NextServer`
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /getMiddlewareManifest/,
+                patchCode: createPatchCode(removeMiddlewareManifestRule),
+            },
+        },
+    ],
+};

package/dist/build/validateConfig.js

@@ -6,6 +6,7 @@ const compatibilityMatrix = {
         "aws-cloudfront",
         "sqs-revalidate",
     ],
+    "aws-lambda-compressed": ["aws-apigw-v2"],
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
     "cloudflare-edge": ["edge"],

package/dist/core/createMainHandler.js

@@ -10,6 +10,8 @@ export async function createMainHandler() {
         : config.default;
     globalThis.serverId = generateUniqueId();
     globalThis.openNextConfig = config;
+    // If route preloading behavior is set to start, it will wait for every single route to be preloaded before even creating the main handler.
+    await globalThis.__next_route_preloader("start");
     // Default queue
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);

package/dist/core/requestHandler.js

@@ -19,6 +19,7 @@ export async function openNextHandler(internalEvent, options) {
         isISRRevalidation: initialHeaders["x-isr"] === "1",
         waitUntil: options?.waitUntil,
     }, async () => {
+        await globalThis.__next_route_preloader("waitUntil");
         if (initialHeaders["x-forwarded-host"]) {
             initialHeaders.host = initialHeaders["x-forwarded-host"];
         }
@@ -114,7 +115,12 @@ export async function openNextHandler(internalEvent, options) {
             // 1. We could just let the revalidation go as normal, but due to race conditions the revalidation will be unreliable
             // 2. We could alter the lastModified time of our cache to make next believe that the cache is fresh, but this could cause issues with stale data since the cdn will cache the stale data as if it was fresh
             // 3. OUR CHOICE: We could pass a purpose prefetch header to the serverless function to make next believe that the request is a prefetch request and not trigger revalidation (This could potentially break in the future if next changes the behavior of prefetch requests)
-            headers: { ...headers, purpose: "prefetch" },
+            headers: {
+                ...headers,
+                //#override appendPrefetch
+                purpose: "prefetch",
+                //#endOverride
+            },
             body: preprocessedEvent.body,
             remoteAddress: preprocessedEvent.remoteAddress,
         };

package/dist/core/routing/matcher.js

@@ -114,19 +114,13 @@ export function handleRewrites(event, rewrites) {
         const { pathname, protocol, hostname, queryString } = getUrlParts(rewrite.destination, isExternalRewrite);
         // We need to use a localized path if the rewrite is not locale specific
         const pathToUse = rewrite.locale === false ? rawPath : localizedRawPath;
-        // We need to encode the "+" character with its UTF-8 equivalent "%20" to avoid 2 issues:
-        // 1. The compile function from path-to-regexp will throw an error if it finds a "+" character.
-        // https://github.com/pillarjs/path-to-regexp?tab=readme-ov-file#unexpected--or-
-        // 2. The convertToQueryString function will replace the "+" character with %2B instead of %20.
-        // %2B does not get interpreted as a space in the URL thus breaking the query string.
-        const encodePlusQueryString = queryString.replaceAll("+", "%20");
         debug("urlParts", { pathname, protocol, hostname, queryString });
-        const toDestinationPath = compile(escapeRegex(pathname));
+        const toDestinationPath = compile(escapeRegex(pathname, { isPath: true }));
         const toDestinationHost = compile(escapeRegex(hostname));
-        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString));
+        const toDestinationQuery = compile(escapeRegex(queryString));
         const params = {
             // params for the source
-            ...getParamsFromSource(match(escapeRegex(rewrite.source)))(pathToUse),
+            ...getParamsFromSource(match(escapeRegex(rewrite.source, { isPath: true })))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
                 return Object.assign(acc, computeHas(cur));
@@ -137,7 +131,7 @@ export function handleRewrites(event, rewrites) {
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
-        let rewrittenQuery = encodePlusQueryString;
+        let rewrittenQuery = queryString;
         let rewrittenHost = hostname;
         let rewrittenPath = pathname;
         if (isUsingParams) {

package/dist/core/routing/middleware.d.ts

@@ -7,5 +7,12 @@ type Middleware = (request: Request) => Response | Promise<Response>;
 type MiddlewareLoader = () => Promise<{
     default: Middleware;
 }>;
-export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
+/**
+ *
+ * @param internalEvent the internal event
+ * @param initialSearch the initial query string as it was received in the handler
+ * @param middlewareLoader Only used for unit test
+ * @returns `Promise<MiddlewareEvent | InternalResult>`
+ */
+export declare function handleMiddleware(internalEvent: InternalEvent, initialSearch: string, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
 export {};

package/dist/core/routing/middleware.js

@@ -1,14 +1,7 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { localizePath } from "./i18n/index.js";
-//NOTE: we should try to avoid importing stuff from next as much as possible
-// every release of next could break this
-// const { run } = require("next/dist/server/web/sandbox");
-// const { getCloneableBody } = require("next/dist/server/body-streams");
-// const {
-//   signalFromNodeResponse,
-// } = require("next/dist/server/web/spec-extension/adapters/next-request");
-import { convertBodyToReadableStream, convertToQueryString, getMiddlewareMatch, isExternal, } from "./util.js";
+import { convertBodyToReadableStream, getMiddlewareMatch, isExternal, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
 const functionsConfigManifest = FunctionsConfigManifest;
 const middleMatch = getMiddlewareMatch(middlewareManifest, functionsConfigManifest);
@@ -16,12 +9,14 @@ function defaultMiddlewareLoader() {
     // @ts-expect-error - This is bundled
     return import("./middleware.mjs");
 }
-// NOTE: As of Nextjs 13.4.13+, the middleware is handled outside the next-server.
-// OpenNext will run the middleware in a sandbox and set the appropriate req headers
-// and res.body prior to processing the next-server.
-// @returns undefined | res.end()
-//    if res.end() is return, the parent needs to return and not process next server
-export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
+/**
+ *
+ * @param internalEvent the internal event
+ * @param initialSearch the initial query string as it was received in the handler
+ * @param middlewareLoader Only used for unit test
+ * @returns `Promise<MiddlewareEvent | InternalResult>`
+ */
+export async function handleMiddleware(internalEvent, initialSearch, middlewareLoader = defaultMiddlewareLoader) {
     const headers = internalEvent.headers;
     // We bypass the middleware if the request is internal
     // We should only do that if the request has the correct `x-prerender-revalidate` header
@@ -36,7 +31,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     if (!hasMatch)
         return internalEvent;
     const initialUrl = new URL(normalizedPath, internalEvent.url);
-    initialUrl.search = convertToQueryString(internalEvent.query);
+    initialUrl.search = initialSearch;
     const url = initialUrl.href;
     const middleware = await middlewareLoader();
     const result = await middleware.default({
@@ -76,13 +71,15 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const responseHeaders = result.headers;
     const reqHeaders = {};
     const resHeaders = {};
-    responseHeaders.delete("x-middleware-override-headers");
-    /*  Next will set the header `x-middleware-set-cookie` when you `set-cookie` in the middleware.
-     *  We can delete it here since it will be set in `set-cookie` aswell. Next removes this header in the response themselves.
-     * `x-middleware-next` is set when you invoke `NextResponse.next()`. We can delete it here aswell.
-     */
-    responseHeaders.delete("x-middleware-set-cookie");
-    responseHeaders.delete("x-middleware-next");
+    // These are internal headers used by Next.js, we don't want to expose them to the client
+    const filteredHeaders = [
+        "x-middleware-override-headers",
+        "x-middleware-set-cookie",
+        "x-middleware-next",
+        "x-middleware-rewrite",
+        // We need to drop `content-encoding` because it will be decoded
+        "content-encoding",
+    ];
     const xMiddlewareKey = "x-middleware-request-";
     responseHeaders.forEach((value, key) => {
         if (key.startsWith(xMiddlewareKey)) {
@@ -90,6 +87,8 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
             reqHeaders[k] = value;
         }
         else {
+            if (filteredHeaders.includes(key.toLowerCase()))
+                return;
             if (key.toLowerCase() === "set-cookie") {
                 resHeaders[key] = resHeaders[key]
                     ? [...resHeaders[key], value]
@@ -100,20 +99,6 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
             }
         }
     });
-    // If the middleware returned a Redirect, we set the `Location` header with
-    // the redirected url and end the response.
-    if (statusCode >= 300 && statusCode < 400) {
-        resHeaders.location =
-            responseHeaders.get("location") ?? resHeaders.location;
-        // res.setHeader("Location", location);
-        return {
-            body: emptyReadableStream(),
-            type: internalEvent.type,
-            statusCode: statusCode,
-            headers: resHeaders,
-            isBase64Encoded: false,
-        };
-    }
     // If the middleware returned a Rewrite, set the `url` to the pathname of the rewrite
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
@@ -139,11 +124,11 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
             });
         }
     }
-    // If the middleware returned a `NextResponse`, pipe the body to res. This will return
-    // the body immediately to the client.
-    if (result.body) {
+    // If the middleware wants to directly return a response (i.e. not using `NextResponse.next()` or `NextResponse.rewrite()`)
+    // we return the response directly
+    if (!rewriteUrl && !responseHeaders.get("x-middleware-next")) {
         // transfer response body to res
-        const body = result.body;
+        const body = result.body ?? emptyReadableStream();
         return {
             type: internalEvent.type,
             statusCode: statusCode,

package/dist/core/routing/util.d.ts

@@ -8,7 +8,7 @@ import type { InternalEvent, InternalResult, RoutingResult, StreamCreator } from
  * @__PURE__
  */
 export declare function isExternal(url?: string, host?: string): boolean;
-export declare function convertFromQueryString(query: string): Record<string, string>;
+export declare function convertFromQueryString(query: string): Record<string, string | string[]>;
 /**
  *
  * @__PURE__
@@ -38,6 +38,7 @@ export declare function convertRes(res: OpenNextNodeResponse): InternalResult;
  * Make sure that multi-value query parameters are transformed to
  * ?key=value1&key=value2&... so that Next converts those parameters
  * to an array when reading the query parameters
+ * query should be properly encoded before using this function
  * @__PURE__
  */
 export declare function convertToQueryString(query: Record<string, string | string[]>): string;
@@ -56,7 +57,9 @@ export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifes
  *
  * @__PURE__
  */
-export declare function escapeRegex(str: string): string;
+export declare function escapeRegex(str: string, { isPath }?: {
+    isPath?: boolean;
+}): string;
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import { Readable } from "node:stream";
 import { BuildId, HtmlPages, NextConfig } from "../../adapters/config/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
-import { parseHeaders } from "../../http/util.js";
+import { getQueryFromIterator, parseHeaders } from "../../http/util.js";
 import { debug, error } from "../../adapters/logger.js";
 import { isBinaryContentType } from "../../utils/binary.js";
 import { localizePath } from "./i18n/index.js";
@@ -24,11 +24,10 @@ export function convertFromQueryString(query) {
     if (query === "")
         return {};
     const queryParts = query.split("&");
-    return queryParts.reduce((acc, part) => {
-        const [key, value] = part.split("=");
-        acc[key] = value;
-        return acc;
-    }, {});
+    return getQueryFromIterator(queryParts.map((p) => {
+        const [key, value] = p.split("=");
+        return [key, value];
+    }));
 }
 /**
  *
@@ -99,23 +98,20 @@ export function convertRes(res) {
  * Make sure that multi-value query parameters are transformed to
  * ?key=value1&key=value2&... so that Next converts those parameters
  * to an array when reading the query parameters
+ * query should be properly encoded before using this function
  * @__PURE__
  */
 export function convertToQueryString(query) {
-    // URLSearchParams is a representation of the PARSED query.
-    // So we must decode the value before appending it to the URLSearchParams.
-    // https://stackoverflow.com/a/45516812
-    const urlQuery = new URLSearchParams();
+    const queryStrings = [];
     Object.entries(query).forEach(([key, value]) => {
         if (Array.isArray(value)) {
-            value.forEach((entry) => urlQuery.append(key, decodeURIComponent(entry)));
+            value.forEach((entry) => queryStrings.push(`${key}=${entry}`));
         }
         else {
-            urlQuery.append(key, decodeURIComponent(value));
+            queryStrings.push(`${key}=${value}`);
         }
     });
-    const queryString = urlQuery.toString();
-    return queryString ? `?${queryString}` : "";
+    return queryStrings.length > 0 ? `?${queryStrings.join("&")}` : "";
 }
 /**
  * Given a raw query string, returns a record with key value-array pairs
@@ -148,11 +144,12 @@ export function getMiddlewareMatch(middlewareManifest, functionsManifest) {
  *
  * @__PURE__
  */
-export function escapeRegex(str) {
-    return str
+export function escapeRegex(str, { isPath } = {}) {
+    const result = str
         .replaceAll("(.)", "_µ1_")
         .replaceAll("(..)", "_µ2_")
         .replaceAll("(...)", "_µ3_");
+    return isPath ? result : result.replaceAll("+", "_µ4_");
 }
 /**
  *
@@ -162,7 +159,8 @@ export function unescapeRegex(str) {
     return str
         .replaceAll("_µ1_", "(.)")
         .replaceAll("_µ2_", "(..)")
-        .replaceAll("_µ3_", "(...)");
+        .replaceAll("_µ3_", "(...)")
+        .replaceAll("_µ4_", "+");
 }
 /**
  * @__PURE__

package/dist/core/routingHandler.js

@@ -58,7 +58,11 @@ export default async function routingHandler(event) {
             debug("redirect", redirect);
             return redirect;
         }
-        const eventOrResult = await handleMiddleware(internalEvent);
+        const eventOrResult = await handleMiddleware(internalEvent, 
+        // We need to pass the initial search without any decoding
+        // TODO: we'd need to refactor InternalEvent to include the initial querystring directly
+        // Should be done in another PR because it is a breaking change
+        new URL(event.url).search);
         const isResult = "statusCode" in eventOrResult;
         if (isResult) {
             return eventOrResult;

package/dist/core/util.js

@@ -1,7 +1,7 @@
 import { AppPathsManifestKeys, NextConfig, RoutesManifest, } from "../adapters/config/index.js";
 // @ts-ignore
 import NextServer from "next/dist/server/next-server.js";
-import { debug } from "../adapters/logger.js";
+import { debug, error } from "../adapters/logger.js";
 import { applyOverride as applyNextjsRequireHooksOverride, overrideHooks as overrideNextjsRequireHooks, } from "./require-hooks.js";
 // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled Reac
 // See https://opennext.js.org/aws/v2/advanced/workaround#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
@@ -48,6 +48,46 @@ const nextServer = new NextServer.default({
     dev: false,
     dir: __dirname,
 });
+let routesLoaded = false;
+globalThis.__next_route_preloader = async (stage) => {
+    if (routesLoaded) {
+        return;
+    }
+    const thisFunction = globalThis.fnName
+        ? globalThis.openNextConfig.functions[globalThis.fnName]
+        : globalThis.openNextConfig.default;
+    const routePreloadingBehavior = thisFunction?.routePreloadingBehavior ?? "none";
+    if (routePreloadingBehavior === "none") {
+        routesLoaded = true;
+        return;
+    }
+    if (!("unstable_preloadEntries" in nextServer)) {
+        debug("The current version of Next.js does not support route preloading. Skipping route preloading.");
+        routesLoaded = true;
+        return;
+    }
+    if (stage === "waitUntil" && routePreloadingBehavior === "withWaitUntil") {
+        // We need to access the waitUntil
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (!waitUntil) {
+            error("You've tried to use the 'withWaitUntil' route preloading behavior, but the 'waitUntil' function is not available.");
+            routesLoaded = true;
+            return;
+        }
+        debug("Preloading entries with waitUntil");
+        waitUntil?.(nextServer.unstable_preloadEntries());
+        routesLoaded = true;
+    }
+    else if ((stage === "start" && routePreloadingBehavior === "onStart") ||
+        (stage === "warmerEvent" && routePreloadingBehavior === "onWarmerEvent") ||
+        stage === "onDemand") {
+        const startTimestamp = Date.now();
+        debug("Preloading entries");
+        await nextServer.unstable_preloadEntries();
+        debug("Preloading entries took", Date.now() - startTimestamp, "ms");
+        routesLoaded = true;
+    }
+};
 // `getRequestHandlerWithMetadata` is not available in older versions of Next.js
 // It is required to for next 15.2 to pass metadata for page router data route
 export const requestHandler = (metadata) => "getRequestHandlerWithMetadata" in nextServer

package/dist/http/util.d.ts

@@ -2,3 +2,10 @@ import type http from "node:http";
 export declare const parseHeaders: (headers?: http.OutgoingHttpHeader[] | http.OutgoingHttpHeaders) => Record<string, string>;
 export declare const convertHeader: (header: http.OutgoingHttpHeader) => string;
 export declare function parseCookies(cookies: string | string[] | null | undefined): string[];
+/**
+ *
+ * Get the query object from an iterable of [key, value] pairs
+ * @param it - The iterable of [key, value] pairs
+ * @returns The query object
+ */
+export declare function getQueryFromIterator(it: Iterable<[string, string]>): Record<string, string | string[]>;

package/dist/http/util.js

@@ -28,3 +28,26 @@ export function parseCookies(cookies) {
         ? cookies.split(/(?<!Expires=\w+),/i).map((c) => c.trim())
         : cookies;
 }
+/**
+ *
+ * Get the query object from an iterable of [key, value] pairs
+ * @param it - The iterable of [key, value] pairs
+ * @returns The query object
+ */
+export function getQueryFromIterator(it) {
+    const query = {};
+    for (const [key, value] of it) {
+        if (key in query) {
+            if (Array.isArray(query[key])) {
+                query[key].push(value);
+            }
+            else {
+                query[key] = [query[key], value];
+            }
+        }
+        else {
+            query[key] = value;
+        }
+    }
+    return query;
+}

package/dist/overrides/converters/edge.js

@@ -1,23 +1,11 @@
 import { Buffer } from "node:buffer";
 import { parseCookies } from "../../http/util";
+import { getQueryFromSearchParams } from "./utils.js";
 const converter = {
     convertFrom: async (event) => {
         const url = new URL(event.url);
         const searchParams = url.searchParams;
-        const query = {};
-        for (const [key, value] of searchParams.entries()) {
-            if (key in query) {
-                if (Array.isArray(query[key])) {
-                    query[key].push(value);
-                }
-                else {
-                    query[key] = [query[key], value];
-                }
-            }
-            else {
-                query[key] = value;
-            }
-        }
+        const query = getQueryFromSearchParams(searchParams);
         // Transform body into Buffer
         const body = await event.arrayBuffer();
         const headers = {};

package/dist/overrides/converters/node.js

@@ -1,5 +1,5 @@
 import { parseCookies } from "../../http/util";
-import { extractHostFromHeaders } from "./utils";
+import { extractHostFromHeaders, getQueryFromSearchParams } from "./utils.js";
 const converter = {
     convertFrom: async (req) => {
         const body = await new Promise((resolve) => {
@@ -18,7 +18,7 @@ const converter = {
         ])
             .filter(([key]) => key));
         const url = new URL(req.url, `http://${extractHostFromHeaders(headers)}`);
-        const query = Object.fromEntries(url.searchParams.entries());
+        const query = getQueryFromSearchParams(url.searchParams);
         return {
             type: "core",
             method: req.method ?? "GET",

package/dist/overrides/converters/utils.d.ts

@@ -6,3 +6,10 @@ export declare function removeUndefinedFromQuery(query: Record<string, string |
  * @returns The host
  */
 export declare function extractHostFromHeaders(headers: Record<string, string>): string;
+/**
+ * Get the query object from an URLSearchParams
+ *
+ * @param searchParams
+ * @returns
+ */
+export declare function getQueryFromSearchParams(searchParams: URLSearchParams): Record<string, string | string[]>;

package/dist/overrides/converters/utils.js

@@ -1,3 +1,4 @@
+import { getQueryFromIterator } from "../../http/util.js";
 export function removeUndefinedFromQuery(query) {
     const newQuery = {};
     for (const [key, value] of Object.entries(query)) {
@@ -16,3 +17,12 @@ export function removeUndefinedFromQuery(query) {
 export function extractHostFromHeaders(headers) {
     return headers["x-forwarded-host"] ?? headers.host ?? "on";
 }
+/**
+ * Get the query object from an URLSearchParams
+ *
+ * @param searchParams
+ * @returns
+ */
+export function getQueryFromSearchParams(searchParams) {
+    return getQueryFromIterator(searchParams.entries());
+}

package/dist/overrides/wrappers/aws-lambda-compressed.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/overrides/wrappers/aws-lambda-compressed.js

@@ -0,0 +1,96 @@
+import { Readable, Writable } from "node:stream";
+import zlib from "node:zlib";
+import { error } from "../../adapters/logger";
+import { formatWarmerResponse } from "./aws-lambda";
+const handler = async (handler, converter) => async (event) => {
+    // Handle warmer event
+    if ("type" in event) {
+        return formatWarmerResponse(event);
+    }
+    const internalEvent = await converter.convertFrom(event);
+    // This is a workaround
+    // https://github.com/opennextjs/opennextjs-aws/blob/e9b37fd44eb856eb8ae73168bf455ff85dd8b285/packages/open-next/src/overrides/wrappers/aws-lambda.ts#L49-L53
+    const fakeStream = {
+        writeHeaders: () => {
+            return new Writable({
+                write: (_chunk, _encoding, callback) => {
+                    callback();
+                },
+            });
+        },
+    };
+    const handlerResponse = await handler(internalEvent, {
+        streamCreator: fakeStream,
+    });
+    // Check if response is already compressed
+    // The handlers response headers are lowercase
+    const alreadyEncoded = handlerResponse.headers["content-encoding"] ?? "";
+    // Return early here if the response is already compressed
+    if (alreadyEncoded) {
+        return converter.convertTo(handlerResponse, event);
+    }
+    // We compress the body if the client accepts it
+    const acceptEncoding = internalEvent.headers["accept-encoding"] ??
+        internalEvent.headers["Accept-Encoding"] ??
+        "";
+    let contentEncoding = null;
+    if (acceptEncoding?.includes("br")) {
+        contentEncoding = "br";
+    }
+    else if (acceptEncoding?.includes("gzip")) {
+        contentEncoding = "gzip";
+    }
+    else if (acceptEncoding?.includes("deflate")) {
+        contentEncoding = "deflate";
+    }
+    const response = {
+        ...handlerResponse,
+        body: compressBody(handlerResponse.body, contentEncoding),
+        headers: {
+            ...handlerResponse.headers,
+            ...(contentEncoding ? { "content-encoding": contentEncoding } : {}),
+        },
+        isBase64Encoded: !!contentEncoding || handlerResponse.isBase64Encoded,
+    };
+    return converter.convertTo(response, event);
+};
+export default {
+    wrapper: handler,
+    name: "aws-lambda-compressed",
+    supportStreaming: false,
+};
+function compressBody(body, encoding) {
+    // If no encoding is specified, return original body
+    if (!encoding)
+        return body;
+    try {
+        const readable = Readable.fromWeb(body);
+        let transform;
+        switch (encoding) {
+            case "br":
+                transform = zlib.createBrotliCompress({
+                    params: {
+                        // This is a compromise between speed and compression ratio.
+                        // The default one will most likely timeout an AWS Lambda with default configuration on large bodies (>6mb).
+                        // Therefore we set it to 6, which is a good compromise.
+                        [zlib.constants.BROTLI_PARAM_QUALITY]: Number(process.env.BROTLI_QUALITY) ?? 6,
+                    },
+                });
+                break;
+            case "gzip":
+                transform = zlib.createGzip();
+                break;
+            case "deflate":
+                transform = zlib.createDeflate();
+                break;
+            default:
+                return body;
+        }
+        return Readable.toWeb(readable.pipe(transform));
+    }
+    catch (e) {
+        error("Error compressing body:", e);
+        // Fall back to no compression on error
+        return body;
+    }
+}

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -14,6 +14,7 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
     if ("type" in event) {
         const result = await formatWarmerResponse(event);
         responseStream.end(Buffer.from(JSON.stringify(result)), "utf-8");
+        await globalThis.__next_route_preloader("warmerEvent");
         return;
     }
     const internalEvent = await converter.convertFrom(event);

package/dist/overrides/wrappers/aws-lambda.d.ts

@@ -1,4 +1,6 @@
 import type { WrapperHandler } from "../../types/overrides";
+import type { WarmerEvent, WarmerResponse } from "../../adapters/warmer-function";
+export declare function formatWarmerResponse(event: WarmerEvent): Promise<WarmerResponse>;
 declare const _default: {
     wrapper: WrapperHandler;
     name: string;

package/dist/overrides/wrappers/aws-lambda.js

@@ -1,5 +1,5 @@
 import { Writable } from "node:stream";
-function formatWarmerResponse(event) {
+export function formatWarmerResponse(event) {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve({ serverId, type: "warmer" });

package/dist/types/aws-lambda.d.ts

@@ -1,5 +1,6 @@
 import type { Writable } from "node:stream";
-import type { APIGatewayProxyEventV2, Context } from "aws-lambda";
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2, CloudFrontRequestEvent, CloudFrontRequestResult, Context } from "aws-lambda";
+import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
 export interface ResponseStream extends Writable {
     getBufferedData(): Buffer;
     setContentType(contentType: string): void;
@@ -17,4 +18,6 @@ declare global {
         }
     }
 }
+export type AwsLambdaEvent = APIGatewayProxyEventV2 | CloudFrontRequestEvent | APIGatewayProxyEvent | WarmerEvent;
+export type AwsLambdaReturn = APIGatewayProxyResultV2 | APIGatewayProxyResult | CloudFrontRequestResult | WarmerResponse;
 export {};

package/dist/types/global.d.ts

@@ -179,5 +179,11 @@ declare global {
      * Defined in `createMainHandler`
      */
     var cdnInvalidationHandler: CDNInvalidationHandler;
+    /**
+     * A function to preload the routes.
+     * This needs to be defined on globalThis because it can be used by custom overrides.
+     * Only available in main functions.
+     */
+    var __next_route_preloader: (stage: "waitUntil" | "start" | "warmerEvent" | "onDemand") => Promise<void>;
 }
 export {};

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

@@ -67,13 +67,23 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
 export type RouteType = "route" | "page" | "app";
 export interface ResolvedRoute {
     route: string;
     type: RouteType;
 }
+/**
+ * The route preloading behavior. Only supported in Next 15+.
+ * Default behavior of Next is disabled. You should do your own testing to choose which one suits you best
+ * - "none" - No preloading of the route at all. This is the default
+ * - "withWaitUntil" - Preload the route using the waitUntil provided by the wrapper - If not supported, it will fallback to "none". At the moment only cloudflare wrappers provide a `waitUntil`
+ * - "onWarmerEvent" - Preload the route on the warmer event - Needs to be implemented by the wrapper. Only supported in `aws-lambda-streaming` wrapper for now
+ * - "onStart" - Preload the route before even invoking the wrapper - This is a blocking operation. The handler will only be created after all the routes have been loaded, it may increase the cold start time by a lot in some cases. Useful for long running server or in serverless with some careful testing
+ * @default "none"
+ */
+export type RoutePreloadingBehavior = "none" | "withWaitUntil" | "onWarmerEvent" | "onStart";
 export interface RoutingResult {
     internalEvent: InternalEvent;
     isExternalRewrite: boolean;
@@ -212,6 +222,7 @@ export interface FunctionOptions extends DefaultFunctionOptions {
      * @deprecated This is not supported in 14.2+
      */
     experimentalBundledNextServer?: boolean;
+    routePreloadingBehavior?: RoutePreloadingBehavior;
 }
 export type RouteTemplate = `app/${string}/route` | `app/${string}/page` | `app/page` | `app/route` | `pages/${string}`;
 export interface SplittedFunctionOptions extends FunctionOptions {

package/package.json

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