@opennextjs/aws 3.2.0 → 3.2.1

package/dist/adapters/cache.d.ts

@@ -88,6 +88,7 @@ export default class S3Cache {
         kindHint?: "app" | "pages" | "fetch";
         tags?: string[];
         softTags?: string[];
+        kind?: "FETCH";
     }): Promise<CacheHandlerValue | null>;
     getFetchCache(key: string, softTags?: string[], tags?: string[]): Promise<CacheHandlerValue | null>;
     getIncrementalCache(key: string): Promise<CacheHandlerValue | null>;

package/dist/adapters/cache.js

@@ -5,6 +5,17 @@ const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
 export function hasCacheExtension(key) {
     return CACHE_EXTENSION_REGEX.test(key);
 }
+function isFetchCache(options) {
+    if (typeof options === "boolean") {
+        return options;
+    }
+    if (typeof options === "object") {
+        return (options.kindHint === "fetch" ||
+            options.fetchCache ||
+            options.kind === "FETCH");
+    }
+    return false;
+}
 // We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
 export default class S3Cache {
     constructor(_ctx) { }
@@ -14,14 +25,9 @@ export default class S3Cache {
         if (globalThis.disableIncrementalCache) {
             return null;
         }
-        const isFetchCache = typeof options === "object"
-            ? options.kindHint
-                ? options.kindHint === "fetch"
-                : options.fetchCache
-            : options;
         const softTags = typeof options === "object" ? options.softTags : [];
         const tags = typeof options === "object" ? options.tags : [];
-        return isFetchCache
+        return isFetchCache(options)
             ? this.getFetchCache(key, softTags, tags)
             : this.getIncrementalCache(key);
     }

package/dist/build/compileConfig.js

@@ -42,6 +42,7 @@ export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExt
 }
 export function compileOpenNextConfigNode(sourcePath, outputDir, externals) {
     const outputPath = path.join(outputDir, "open-next.config.mjs");
+    logger.debug("Compiling open-next.config.ts for Node.", outputPath);
     //Check if open-next.config.ts exists
     if (!fs.existsSync(sourcePath)) {
         //Create a simple open-next.config.mjs file
@@ -71,7 +72,7 @@ export function compileOpenNextConfigNode(sourcePath, outputDir, externals) {
 }
 export function compileOpenNextConfigEdge(sourcePath, outputDir, externals) {
     const outputPath = path.join(outputDir, "open-next.config.edge.mjs");
-    logger.info("Compiling open-next.config.ts for edge runtime.", outputPath);
+    logger.debug("Compiling open-next.config.ts for edge runtime.", outputPath);
     buildSync({
         entryPoints: [sourcePath],
         outfile: outputPath,
@@ -82,5 +83,4 @@ export function compileOpenNextConfigEdge(sourcePath, outputDir, externals) {
         platform: "browser",
         external: externals,
     });
-    logger.info("Compiled open-next.config.ts for edge runtime.");
 }

package/dist/build/copyTracedFiles.js

@@ -54,7 +54,7 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
                 throw new Error(`
 --------------------------------------------------------------------------------
 ${pagePath} cannot use the edge runtime.
-OpenNext requires edge runtime function to be defined in a separate function. 
+OpenNext requires edge runtime function to be defined in a separate function.
 See the docs for more information on how to bundle edge runtime functions.
 --------------------------------------------------------------------------------
         `);
@@ -71,7 +71,7 @@ File ${fullFilePath} does not exist
         extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
             filesToCopy.set(f, f.replace(standaloneDir, outputDir));
         });
-        if (!existsSync(path.join(standaloneNextDir, `${fullFilePath}`))) {
+        if (!existsSync(path.join(standaloneNextDir, fullFilePath))) {
             throw new Error(`This error should only happen for static 404 and 500 page from page router. Report this if that's not the case.,
         File ${fullFilePath} does not exist`);
         }

package/dist/build/createImageOptimizationBundle.js

@@ -75,5 +75,8 @@ export async function createImageOptimizationBundle(options) {
     const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
     installDependencies(outputPath, config.imageOptimization?.install ?? {
         packages: [`sharp@${sharpVersion}`],
+        arch: "arm64",
+        nodeVersion: "18",
+        libc: "glibc",
     });
 }

package/dist/build/createMiddleware.d.ts

@@ -3,8 +3,8 @@ import * as buildHelper from "./helper.js";
  * Compiles the middleware bundle.
  *
  * @param options Build Options.
- * @returns Whether the app uses a Middleware.
+ * @param forceOnlyBuildOnce force to build only once.
  */
-export declare function createMiddleware(options: buildHelper.BuildOptions): Promise<{
-    useMiddleware: boolean;
-}>;
+export declare function createMiddleware(options: buildHelper.BuildOptions, { forceOnlyBuildOnce }?: {
+    forceOnlyBuildOnce?: boolean | undefined;
+}): Promise<void>;

package/dist/build/createMiddleware.js

@@ -8,26 +8,16 @@ import { installDependencies } from "./installDeps.js";
  * Compiles the middleware bundle.
  *
  * @param options Build Options.
- * @returns Whether the app uses a Middleware.
+ * @param forceOnlyBuildOnce force to build only once.
  */
-export async function createMiddleware(options) {
+export async function createMiddleware(options, { forceOnlyBuildOnce = false } = {}) {
     logger.info(`Bundling middleware function...`);
     const { appBuildOutputPath, config, outputDir } = options;
     // Get middleware manifest
     const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
-    const entry = middlewareManifest.middleware["/"];
-    if (!entry) {
-        return { useMiddleware: false };
-    }
-    // Create output folder
-    let outputPath = path.join(outputDir, "server-function");
-    const commonMiddlewareOptions = {
-        middlewareInfo: entry,
-        options,
-        appBuildOutputPath,
-    };
+    const middlewareInfo = middlewareManifest.middleware["/"];
     if (config.middleware?.external) {
-        outputPath = path.join(outputDir, "middleware");
+        const outputPath = path.join(outputDir, "middleware");
         fs.mkdirSync(outputPath, { recursive: true });
         // Copy open-next.config.mjs
         buildHelper.copyOpenNextConfig(options.buildDir, outputPath, config.middleware.override?.wrapper === "cloudflare");
@@ -35,11 +25,13 @@ export async function createMiddleware(options) {
         await buildEdgeBundle({
             entrypoint: path.join(options.openNextDistDir, "adapters", "middleware.js"),
             outfile: path.join(outputPath, "handler.mjs"),
-            ...commonMiddlewareOptions,
+            middlewareInfo,
+            options,
             overrides: config.middleware?.override,
             defaultConverter: "aws-cloudfront",
             includeCache: config.dangerous?.enableCacheInterception,
             additionalExternals: config.edgeExternals,
+            onlyBuildOnce: forceOnlyBuildOnce === true,
         });
         installDependencies(outputPath, config.middleware?.install);
     }
@@ -47,9 +39,9 @@ export async function createMiddleware(options) {
         await buildEdgeBundle({
             entrypoint: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
             outfile: path.join(options.buildDir, "middleware.mjs"),
-            ...commonMiddlewareOptions,
+            middlewareInfo,
+            options,
             onlyBuildOnce: true,
         });
     }
-    return { useMiddleware: true };
 }

package/dist/build/createServerBundle.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
@@ -11,7 +10,6 @@ import { copyTracedFiles } from "./copyTracedFiles.js";
 import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
-const require = createRequire(import.meta.url);
 export async function createServerBundle(options) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -27,17 +25,17 @@ export async function createServerBundle(options) {
         const routes = fnOptions.routes;
         routes.forEach((route) => foundRoutes.add(route));
         if (fnOptions.runtime === "edge") {
-            await generateEdgeBundle(name, config, options, fnOptions);
+            await generateEdgeBundle(name, options, fnOptions);
         }
         else {
-            await generateBundle(name, config, options, fnOptions);
+            await generateBundle(name, options, fnOptions);
         }
     });
     //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
     // We build every other function than default before so we know which route there is left
     await Promise.all(promises);
     const remainingRoutes = new Set();
-    const { monorepoRoot, appBuildOutputPath } = options;
+    const { appBuildOutputPath, monorepoRoot } = options;
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     // Find remaining routes
     const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
@@ -68,15 +66,15 @@ export async function createServerBundle(options) {
         }, () => { });
     }
     // Generate default function
-    await generateBundle("default", config, options, {
+    await generateBundle("default", options, {
         ...defaultFn,
         // @ts-expect-error - Those string are RouteTemplate
         routes: Array.from(remainingRoutes),
         patterns: ["*"],
     });
 }
-async function generateBundle(name, config, options, fnOptions) {
-    const { appPath, appBuildOutputPath, outputDir, monorepoRoot } = options;
+async function generateBundle(name, options, fnOptions) {
+    const { appPath, appBuildOutputPath, config, outputDir, monorepoRoot } = options;
     logger.info(`Building server function: ${name}...`);
     // Create output folder
     const outputPath = path.join(outputDir, "server-functions", name);
@@ -99,8 +97,7 @@ async function generateBundle(name, config, options, fnOptions) {
         await bundleNextServer(path.join(outputPath, packagePath), appPath);
     }
     // Copy middleware
-    if (!config.middleware?.external &&
-        fs.existsSync(path.join(options.buildDir, "middleware.mjs"))) {
+    if (!config.middleware?.external) {
         fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
     }
     // Copy open-next.config.mjs
@@ -123,12 +120,10 @@ async function generateBundle(name, config, options, fnOptions) {
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
             target: /core(\/|\\)requestHandler\.js/g,
-            deletes: disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : [],
-            replacements: disableRouting
-                ? [
-                    require.resolve("../adapters/plugins/without-routing/requestHandler.js"),
-                ]
-                : [],
+            deletes: [
+                ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
+                ...(disableRouting ? ["withRouting"] : []),
+            ],
         }),
         openNextReplacementPlugin({
             name: `utilOverride ${name}`,

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,9 +1,8 @@
 import type { MiddlewareInfo } from "../../types/next-types";
-import type { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { IncludedConverter, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
 import type { BuildOptions } from "../helper.js";
 interface BuildEdgeBundleOptions {
-    appBuildOutputPath: string;
-    middlewareInfo: MiddlewareInfo;
+    middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
@@ -14,7 +13,6 @@ interface BuildEdgeBundleOptions {
     additionalExternals?: string[];
     onlyBuildOnce?: boolean;
 }
-export declare function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
-export declare function copyMiddlewareAssetsAndWasm({}: {}): void;
-export declare function generateEdgeBundle(name: string, config: OpenNextConfig, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
+export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
+export declare function generateEdgeBundle(name: string, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
 export {};

package/dist/build/edge/createEdgeBundle.js

@@ -7,7 +7,7 @@ import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
     const isInCloudfare = typeof overrides?.wrapper === "string"
         ? overrides.wrapper === "cloudflare"
         : (await overrides?.wrapper?.())?.edgeRuntime;
@@ -50,7 +50,7 @@ export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entr
             }),
             openNextEdgePlugins({
                 middlewareInfo,
-                nextDir: path.join(appBuildOutputPath, ".next"),
+                nextDir: path.join(options.appBuildOutputPath, ".next"),
                 edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
                 isInCloudfare,
             }),
@@ -106,8 +106,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
         });
     }
 }
-export function copyMiddlewareAssetsAndWasm({}) { }
-export async function generateEdgeBundle(name, config, options, fnOptions) {
+export async function generateEdgeBundle(name, options, fnOptions) {
     const { appBuildOutputPath, outputDir } = options;
     logger.info(`Generating edge bundle for: ${name}`);
     // Create output folder
@@ -122,26 +121,25 @@ export async function generateEdgeBundle(name, config, options, fnOptions) {
     if (functions.length > 1) {
         throw new Error("Only one function is supported for now");
     }
-    const fn = functions[0];
+    const middlewareInfo = functions[0];
     //Copy wasm files
-    const wasmFiles = fn.wasm;
+    const wasmFiles = middlewareInfo.wasm;
     mkdirSync(path.join(outputPath, "wasm"), { recursive: true });
     for (const wasmFile of wasmFiles) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", wasmFile.filePath), path.join(outputPath, `wasm/${wasmFile.name}.wasm`));
     }
     // Copy assets
-    const assets = fn.assets;
+    const assets = middlewareInfo.assets;
     mkdirSync(path.join(outputPath, "assets"), { recursive: true });
     for (const asset of assets) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", asset.filePath), path.join(outputPath, `assets/${asset.name}`));
     }
     await buildEdgeBundle({
-        appBuildOutputPath,
-        middlewareInfo: fn,
+        middlewareInfo,
         entrypoint: path.join(options.openNextDistDir, "adapters", "edge-adapter.js"),
         outfile: path.join(outputPath, "index.mjs"),
         options,
         overrides: fnOptions.override,
-        additionalExternals: config.edgeExternals,
+        additionalExternals: options.config.edgeExternals,
     });
 }

package/dist/build/installDeps.js

@@ -14,7 +14,17 @@ export function installDependencies(outputDir, installOptions) {
         logger.info(`Installing dependencies for ${name}...`);
         // We then need to run install in the tempDir
         // We don't install in the output dir directly because it could contain a package.json, and npm would then try to reinstall not complete deps from tracing the files
-        const installCommand = `npm install --arch=${installOptions.arch ?? "arm64"} --platform=linux --target=${installOptions.nodeVersion ?? "18"} --libc=${installOptions.libc ?? "glibc"} ${installOptions.packages.join(" ")}`;
+        const archOption = installOptions.arch
+            ? `--arch=${installOptions.arch}`
+            : "";
+        const targetOption = installOptions.nodeVersion
+            ? `--target=${installOptions.nodeVersion}`
+            : "";
+        const libcOption = installOptions.libc
+            ? `--libc=${installOptions.libc}`
+            : "";
+        const additionalArgs = installOptions.additionalArgs ?? "";
+        const installCommand = `npm install --platform=linux ${archOption} ${targetOption} ${libcOption} ${additionalArgs} ${installOptions.packages.join(" ")}`;
         execSync(installCommand, {
             stdio: "pipe",
             cwd: tempInstallDir,

package/dist/core/createGenericHandler.js

@@ -7,10 +7,10 @@ export async function createGenericHandler(handler) {
     globalThis.openNextConfig = config;
     const override = config[handler.type]
         ?.override;
-    // From the config, we create the adapter
-    const adapter = await resolveConverter(override?.converter);
+    // From the config, we create the converter
+    const converter = await resolveConverter(override?.converter);
     // Then we create the handler
-    const wrapper = await resolveWrapper(override?.wrapper);
-    debug("Using wrapper", wrapper.name);
-    return wrapper.wrapper(handler.handler, adapter);
+    const { name, wrapper } = await resolveWrapper(override?.wrapper);
+    debug("Using wrapper", name);
+    return wrapper(handler.handler, converter);
 }

package/dist/core/createMainHandler.js

@@ -15,10 +15,10 @@ export async function createMainHandler() {
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
     globalThis.lastModified = {};
-    // From the config, we create the adapter
-    const adapter = await resolveConverter(thisFunction.override?.converter);
+    // From the config, we create the converter
+    const converter = await resolveConverter(thisFunction.override?.converter);
     // Then we create the handler
-    const wrapper = await resolveWrapper(thisFunction.override?.wrapper);
-    debug("Using wrapper", wrapper.name);
-    return wrapper.wrapper(openNextHandler, adapter);
+    const { wrapper, name } = await resolveWrapper(thisFunction.override?.wrapper);
+    debug("Using wrapper", name);
+    return wrapper(openNextHandler, converter);
 }

package/dist/core/requestHandler.js

@@ -14,13 +14,13 @@ export async function openNextHandler(internalEvent, responseStreaming) {
         internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
     }
     debug("internalEvent", internalEvent);
-    //#override withRouting
     let preprocessResult = {
         internalEvent: internalEvent,
         isExternalRewrite: false,
         origin: false,
         isISR: false,
     };
+    //#override withRouting
     try {
         preprocessResult = await routingHandler(internalEvent);
     }

package/dist/core/routing/matcher.js

@@ -122,10 +122,16 @@ 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 toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
-        const toDestinationQuery = compile(escapeRegex(queryString ?? "") ?? "");
+        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
         let params = {
             // params for the source
             ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
@@ -139,7 +145,7 @@ export function handleRewrites(event, rewrites) {
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
-        let rewrittenQuery = queryString;
+        let rewrittenQuery = encodePlusQueryString;
         let rewrittenHost = hostname;
         let rewrittenPath = pathname;
         if (isUsingParams) {
@@ -149,7 +155,7 @@ export function handleRewrites(event, rewrites) {
         }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
-            : `/${rewrittenPath}`;
+            : `${rewrittenPath}`;
         // Should we merge the query params or use only the ones from the rewrite?
         finalQuery = {
             ...query,
@@ -244,8 +250,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        let newPath = rawPath.replace(dataPattern, "").replace(/\.json$/, "");
-        newPath = newPath === "/index" ? "/" : newPath;
+        const newPath = rawPath
+            .slice(dataPattern.length, -".json".length)
+            .replace(/^\/index$/, "/");
         query.__nextDataReq = "1";
         return {
             ...internalEvent,

package/dist/core/routing/middleware.js

@@ -30,13 +30,16 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // We bypass the middleware if the request is internal
     if (internalEvent.headers["x-isr"])
         return internalEvent;
+    // Retrieve the protocol:
+    // - In lambda, the url only contains the rawPath and the query - default to https
+    // - In cloudflare, the protocol is usually http in dev and https in production
+    const protocol = internalEvent.url.startsWith("http://") ? "http:" : "https:";
     const host = internalEvent.headers.host
-        ? `https://${internalEvent.headers.host}`
+        ? `${protocol}//${internalEvent.headers.host}`
         : "http://localhost:3000";
     const initialUrl = new URL(normalizedPath, host);
     initialUrl.search = convertToQueryString(query);
     const url = initialUrl.toString();
-    // console.log("url", url, normalizedPath);
     const middleware = await middlewareLoader();
     const result = await middleware.default({
         geo: {
@@ -96,7 +99,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         resHeaders.location =
             responseHeaders
                 .get("location")
-                ?.replace("http://localhost:3000", `https://${internalEvent.headers.host}`) ?? resHeaders.location;
+                ?.replace("http://localhost:3000", `${protocol}//${internalEvent.headers.host}`) ?? resHeaders.location;
         // res.setHeader("Location", location);
         return {
             body: emptyReadableStream(),

package/dist/core/routing/util.js

@@ -37,7 +37,7 @@ export function getUrlParts(url, isExternal) {
         const match = url.match(regex);
         return {
             hostname: "",
-            pathname: match?.[1] ?? url,
+            pathname: match?.[1] ? `/${match[1]}` : url,
             protocol: "",
             queryString: match?.[2] ?? "",
         };
@@ -50,7 +50,7 @@ export function getUrlParts(url, isExternal) {
     return {
         protocol: match[1] ?? "https:",
         hostname: match[2],
-        pathname: match[3],
+        pathname: match[3] ?? "",
         queryString: match[4]?.slice(1) ?? "",
     };
 }
@@ -84,13 +84,16 @@ export function convertRes(res) {
  * @__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();
     Object.entries(query).forEach(([key, value]) => {
         if (Array.isArray(value)) {
-            value.forEach((entry) => urlQuery.append(key, entry));
+            value.forEach((entry) => urlQuery.append(key, decodeURIComponent(entry)));
         }
         else {
-            urlQuery.append(key, value);
+            urlQuery.append(key, decodeURIComponent(value));
         }
     });
     const queryString = urlQuery.toString();

package/dist/core/routingHandler.js

@@ -30,7 +30,7 @@ function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = tru
     });
 }
 export default async function routingHandler(event) {
-    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders) ?? {};
+    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders);
     let internalEvent = fixDataPage(event, BuildId);
     if ("statusCode" in internalEvent) {
         return internalEvent;

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

@@ -1,5 +1,8 @@
 import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
 import type { MiddlewareOutputEvent } from "../../core/routingHandler";
+declare global {
+    var __dangerous_ON_edge_converter_returns_request: boolean | undefined;
+}
 declare const converter: Converter<InternalEvent, InternalResult | ({
     type: "middleware";
 } & MiddlewareOutputEvent)>;

package/dist/overrides/converters/edge.js

@@ -52,7 +52,7 @@ const converter = {
                     url = `https://${result.internalEvent.headers.host}${url}`;
                 }
             }
-            const req = new Request(url, {
+            const request = new Request(url, {
                 body: result.internalEvent.body,
                 method: result.internalEvent.method,
                 headers: {
@@ -60,12 +60,15 @@ const converter = {
                     "x-forwarded-host": result.internalEvent.headers.host,
                 },
             });
+            if (globalThis.__dangerous_ON_edge_converter_returns_request === true) {
+                return request;
+            }
             const cfCache = (result.isISR ||
                 result.internalEvent.rawPath.startsWith("/_next/image")) &&
                 process.env.DISABLE_CACHE !== "true"
                 ? { cacheEverything: true }
                 : {};
-            return fetch(req, {
+            return fetch(request, {
                 // This is a hack to make sure that the response is cached by Cloudflare
                 // See https://developers.cloudflare.com/workers/examples/cache-using-fetch/#caching-html-resources
                 // @ts-expect-error - This is a Cloudflare specific option

package/dist/overrides/wrappers/cloudflare.js

@@ -1,7 +1,7 @@
 const handler = async (handler, converter) => async (event, env) => {
     globalThis.process = process;
     // Set the environment variables
-    // Cloudlare suggests to not override the process.env object but instead apply the values to it
+    // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
         if (typeof value === "string") {
             process.env[key] = value;

package/dist/plugins/edge.d.ts

@@ -3,13 +3,14 @@ import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
     edgeFunctionHandlerPath?: string;
-    middlewareInfo: MiddlewareInfo;
+    middlewareInfo?: MiddlewareInfo;
     isInCloudfare?: boolean;
 }
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
- * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @param opts.middlewareInfo - Information about the middleware
+ * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
 export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -4,19 +4,22 @@ import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, l
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
- * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @param opts.middlewareInfo - Information about the middleware
+ * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
 export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
-    const entryFiles = middlewareInfo.files.map((file) => path.join(nextDir, file));
-    const routes = [
-        {
-            name: middlewareInfo.name || "/",
-            page: middlewareInfo.page,
-            regex: middlewareInfo.matchers.map((m) => m.regexp),
-        },
-    ];
-    const wasmFiles = middlewareInfo.wasm ?? [];
+    const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
+    const routes = middlewareInfo
+        ? [
+            {
+                name: middlewareInfo.name || "/",
+                page: middlewareInfo.page,
+                regex: middlewareInfo.matchers.map((m) => m.regexp),
+            },
+        ]
+        : [];
+    const wasmFiles = middlewareInfo?.wasm ?? [];
     return {
         name: "opennext-edge",
         setup(build) {
@@ -44,12 +47,10 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
             });
             // we convert the imports we tagged with the node-built-in-modules namespace so that instead of `require("node:*")`
             // they import from `export * from "node:*";`
-            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => {
-                return {
-                    contents: `export * from '${path}'`,
-                    loader: "js",
-                };
-            });
+            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => ({
+                contents: `export * from '${path}'`,
+                loader: "js",
+            }));
             // We inject the entry files into the edgeFunctionHandler
             build.onLoad({ filter: /\/edgeFunctionHandler.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
@@ -97,7 +98,7 @@ if(!globalThis.Crypto) {
   globalThis.Crypto = webcrypto.Crypto
 }
 // We also need to polyfill URLPattern
-if (!globalThis.URLPattern) { 
+if (!globalThis.URLPattern) {
   await import("urlpattern-polyfill");
 }
 `}
@@ -106,8 +107,8 @@ ${wasmFiles
                     ? `import ${file.name} from './wasm/${file.name}.wasm';`
                     : `const ${file.name} = readFileSync(path.join(__dirname,'/wasm/${file.name}.wasm'));`)
                     .join("\n")}
-${entryFiles?.map((file) => `require("${file}");`).join("\n")}
-${contents}        
+${entryFiles.map((file) => `require("${file}");`).join("\n")}
+${contents}
         `;
                 return {
                     contents,
@@ -124,18 +125,18 @@ ${contents}
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const contents = `
   import path from "path";
-  
+
   import { debug } from "../logger";
-  
+
   if(!globalThis.__dirname) {
     globalThis.__dirname = ""
   }
-  
+
   export const NEXT_DIR = path.join(__dirname, ".next");
   export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
-  
+
   debug({ NEXT_DIR, OPEN_NEXT_DIR });
-  
+
   export const NextConfig = ${JSON.stringify(NextConfig)};
   export const BuildId = ${JSON.stringify(BuildId)};
   export const HtmlPages = ${JSON.stringify(HtmlPages)};
@@ -146,11 +147,8 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
 
   process.env.NEXT_BUILD_ID = BuildId;
-  
-          `;
-                return {
-                    contents,
-                };
+`;
+                return { contents };
             });
         },
     };

package/dist/plugins/replacement.d.ts

@@ -13,7 +13,7 @@ export interface IPluginSettings {
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *

package/dist/plugins/replacement.js

@@ -11,7 +11,7 @@ const importPattern = /\/\/#import([\s\S]*?)\n\/\/#endImport/gm;
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *
@@ -49,9 +49,8 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                         logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), ` -- Deleting override for ${id}`);
                         contents = contents.replace(pattern, "");
                     }),
-                    ...(replacements ?? []).map(async (fp) => {
-                        const p = fp;
-                        const replacementFile = await readFile(p, "utf-8");
+                    ...(replacements ?? []).map(async (filename) => {
+                        const replacementFile = await readFile(filename, "utf-8");
                         const matches = replacementFile.matchAll(overridePattern);
                         const importMatch = replacementFile.match(importPattern);
                         const addedImport = importMatch ? importMatch[0] : "";
@@ -60,7 +59,7 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                             const replacement = match[2];
                             const id = match[1];
                             const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`, "g");
-                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${fp}`);
+                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${filename}`);
                             contents = contents.replace(pattern, replacement);
                         }
                     }),

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

@@ -143,17 +143,22 @@ export interface InstallOptions {
      */
     packages: string[];
     /**
-     * @default "arm64"
+     * @default undefined
      */
     arch?: "x64" | "arm64";
     /**
-     * @default "18"
+     * @default undefined
      */
-    nodeVersion?: "18" | "20" | "22";
+    nodeVersion?: string;
     /**
-     * @default "glibc"
+     * @default undefined
      */
     libc?: "glibc" | "musl";
+    /**
+     * @default undefined
+     * Additional arguments to pass to the install command (i.e. npm install)
+     */
+    additionalArgs?: string;
 }
 export interface DefaultFunctionOptions<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> {
     /**

package/package.json

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

package/dist/adapters/plugins/without-routing/requestHandler.d.ts

@@ -1,2 +0,0 @@
-declare const _default: {};
-export default _default;

package/dist/adapters/plugins/without-routing/requestHandler.js

@@ -1,10 +0,0 @@
-//#override withRouting
-const preprocessResult = {
-    internalEvent: internalEvent,
-    isExternalRewrite: false,
-    origin: false,
-    isISR: false,
-};
-//#endOverride
-// We need to export something otherwise when compiled in js it creates an empty export {} inside the override
-export default {};