@opennextjs/aws 3.2.0 → 3.2.2

package/dist/build/generateOutput.js

@@ -6,15 +6,11 @@ async function canStream(opts) {
     if (!opts.override?.wrapper) {
         return false;
     }
-    else {
-        if (typeof opts.override.wrapper === "string") {
-            return opts.override.wrapper === "aws-lambda-streaming";
-        }
-        else {
-            const wrapper = await opts.override.wrapper();
-            return wrapper.supportStreaming;
-        }
+    if (typeof opts.override.wrapper === "string") {
+        return opts.override.wrapper === "aws-lambda-streaming";
     }
+    const wrapper = await opts.override.wrapper();
+    return wrapper.supportStreaming;
 }
 async function extractOverrideName(defaultName, override) {
     if (!override) {
@@ -23,10 +19,8 @@ async function extractOverrideName(defaultName, override) {
     if (typeof override === "string") {
         return override;
     }
-    else {
-        const overrideModule = await override();
-        return overrideModule.name;
-    }
+    const overrideModule = await override();
+    return overrideModule.name;
 }
 async function extractOverrideFn(override) {
     if (!override) {
@@ -190,7 +184,7 @@ export async function generateOutput(options) {
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });
     behaviors.push({
-        pattern: "*",
+        pattern: "*", // This is the default behavior
         origin: "default",
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });

package/dist/build/helper.d.ts

@@ -19,15 +19,33 @@ export declare function normalizeOptions(config: OpenNextConfig, distDir: string
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
-export declare function removeFiles(root: string, conditionFn: (file: string) => boolean, searchingDir?: string): void;
+/**
+ *  Type of the parameter of `traverseFiles` callbacks
+ */
+export type TraversePath = {
+    absolutePath: string;
+    relativePath: string;
+};
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
-export declare function traverseFiles(root: string, conditionFn: (file: string) => boolean, callbackFn: (filePath: string) => void, searchingDir?: string): void;
+export declare function traverseFiles(root: string, conditionFn: (paths: TraversePath) => boolean, callbackFn: (paths: TraversePath) => void, searchingDir?: string): void;
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export declare function removeFiles(root: string, conditionFn: (paths: TraversePath) => boolean): void;
 export declare function getHtmlPages(dotNextPath: string): Set<string>;
 export declare function getBuildId(dotNextPath: string): string;
 export declare function getOpenNextVersion(): string;

package/dist/build/helper.js

@@ -74,7 +74,7 @@ export function esbuildSync(esbuildOptions, options) {
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify: !debug,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -101,7 +101,7 @@ export async function esbuildAsync(esbuildOptions, options) {
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify: !debug,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -125,28 +125,40 @@ export async function esbuildAsync(esbuildOptions, options) {
         throw new Error(`There was a problem bundling ${esbuildOptions.entryPoints[0]}.`);
     }
 }
-export function removeFiles(root, conditionFn, searchingDir = "") {
-    traverseFiles(root, conditionFn, (filePath) => fs.rmSync(filePath, { force: true }), searchingDir);
-}
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
 export function traverseFiles(root, conditionFn, callbackFn, searchingDir = "") {
     fs.readdirSync(path.join(root, searchingDir)).forEach((file) => {
-        const filePath = path.join(root, searchingDir, file);
-        if (fs.statSync(filePath).isDirectory()) {
-            traverseFiles(root, conditionFn, callbackFn, path.join(searchingDir, file));
+        const relativePath = path.join(searchingDir, file);
+        const absolutePath = path.join(root, relativePath);
+        if (fs.statSync(absolutePath).isDirectory()) {
+            traverseFiles(root, conditionFn, callbackFn, relativePath);
             return;
         }
-        if (conditionFn(path.join(searchingDir, file))) {
-            callbackFn(filePath);
+        if (conditionFn({ absolutePath, relativePath })) {
+            callbackFn({ absolutePath, relativePath });
         }
     });
 }
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export function removeFiles(root, conditionFn) {
+    traverseFiles(root, conditionFn, ({ absolutePath }) => fs.rmSync(absolutePath, { force: true }));
+}
 export function getHtmlPages(dotNextPath) {
     // Get a list of HTML pages
     //
@@ -187,9 +199,11 @@ export function compareSemver(v1, v2) {
     if (v1 === "latest")
         return 1;
     if (/^[^\d]/.test(v1)) {
+        // biome-ignore lint/style/noParameterAssign:
         v1 = v1.substring(1);
     }
     if (/^[^\d]/.test(v2)) {
+        // biome-ignore lint/style/noParameterAssign:
         v2 = v2.substring(1);
     }
     const [major1, minor1, patch1] = v1.split(".").map(Number);

package/dist/build/installDeps.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execSync } from "child_process";
+import { execSync } from "node:child_process";
 import logger from "../logger.js";
 export function installDependencies(outputDir, installOptions) {
     try {
@@ -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/build/patch/patchedAsyncStorage.js

@@ -8,7 +8,7 @@ const staticGenerationAsyncStorage = {
         if (store) {
             store.isOnDemandRevalidate =
                 store.isOnDemandRevalidate &&
-                    !globalThis.__als.getStore().isISRRevalidation;
+                    !globalThis.__openNextAls.getStore().isISRRevalidation;
         }
         return store;
     },

package/dist/build/utils.js

@@ -1,12 +1,13 @@
 import os from "node:os";
 import logger from "../logger.js";
 export function printHeader(header) {
+    // biome-ignore lint/style/noParameterAssign:
     header = `OpenNext — ${header}`;
     logger.info([
         "",
-        "┌" + "─".repeat(header.length + 2) + "┐",
+        `┌${"─".repeat(header.length + 2)}┐`,
         `│ ${header} │`,
-        "└" + "─".repeat(header.length + 2) + "┘",
+        `└${"─".repeat(header.length + 2)}┘`,
         "",
     ].join("\n"));
 }

package/dist/build/validateConfig.js

@@ -9,6 +9,7 @@ const compatibilityMatrix = {
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
     node: ["node"],
+    dummy: [],
 };
 function validateFunctionOptions(fnOptions) {
     if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {

package/dist/core/createGenericHandler.d.ts

@@ -1,7 +1,5 @@
-import type { BaseEventOrResult, InternalEvent, InternalResult, OpenNextConfig, OpenNextHandler } from "../types/open-next";
-declare global {
-    var openNextConfig: Partial<OpenNextConfig>;
-}
+import type { BaseEventOrResult, InternalEvent, InternalResult } from "../types/open-next";
+import type { OpenNextHandler } from "../types/overrides";
 type HandlerType = "imageOptimization" | "revalidate" | "warmer" | "middleware" | "initializationFunction";
 type GenericHandler<Type extends HandlerType, E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = {
     handler: OpenNextHandler<E, R>;

package/dist/core/createGenericHandler.js

@@ -1,16 +1,15 @@
 import { debug } from "../adapters/logger";
 import { resolveConverter, resolveWrapper } from "./resolve";
 export async function createGenericHandler(handler) {
-    //First we load the config
-    // @ts-expect-error
+    // @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;
-    // 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.d.ts

@@ -1,18 +1 @@
-/// <reference types="node" />
-import type { AsyncLocalStorage } from "node:async_hooks";
-import type { DetachedPromiseRunner } from "../utils/promise";
-import type { IncrementalCache } from "../overrides/incrementalCache/types";
-import type { Queue } from "../overrides/queue/types";
-declare global {
-    var queue: Queue;
-    var incrementalCache: IncrementalCache;
-    var fnName: string | undefined;
-    var serverId: string;
-    var __als: AsyncLocalStorage<{
-        requestId: string;
-        pendingPromiseRunner: DetachedPromiseRunner;
-        isISRRevalidation?: boolean;
-        mergeHeadersPriority?: "middleware" | "handler";
-    }>;
-}
 export declare function createMainHandler(): Promise<(...args: any[]) => any>;

package/dist/core/createMainHandler.js

@@ -1,10 +1,10 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
-import { openNextHandler } from "./requestHandler.js";
-import { resolveConverter, resolveIncrementalCache, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { openNextHandler } from "./requestHandler";
+import { resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
-    //First we load the config
-    const config = await import(process.cwd() + "/open-next.config.mjs").then((m) => m.default);
+    // @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);
     const thisFunction = globalThis.fnName
         ? config.functions[globalThis.fnName]
         : config.default;
@@ -14,11 +14,12 @@ export async function createMainHandler() {
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
+    globalThis.proxyExternalRequest = await resolveProxyRequest(thisFunction.override?.proxyExternalRequest);
     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/edgeFunctionHandler.d.ts

@@ -1,54 +1,4 @@
-/// <reference types="node" />
-import type { OutgoingHttpHeaders } from "http";
-interface RequestData {
-    geo?: {
-        city?: string;
-        country?: string;
-        region?: string;
-        latitude?: string;
-        longitude?: string;
-    };
-    headers: OutgoingHttpHeaders;
-    ip?: string;
-    method: string;
-    nextConfig?: {
-        basePath?: string;
-        i18n?: any;
-        trailingSlash?: boolean;
-    };
-    page?: {
-        name?: string;
-        params?: {
-            [key: string]: string | string[];
-        };
-    };
-    url: string;
-    body?: ReadableStream<Uint8Array>;
-    signal: AbortSignal;
-}
-interface Entries {
-    [k: string]: {
-        default: (props: {
-            page: string;
-            request: RequestData;
-        }) => Promise<{
-            response: Response;
-            waitUntil: Promise<void>;
-        }>;
-    };
-}
-declare global {
-    var _ENTRIES: Entries;
-    var _ROUTES: EdgeRoute[];
-    var __storage__: Map<unknown, unknown>;
-    var AsyncContext: any;
-    var AsyncLocalStorage: any;
-}
-export interface EdgeRoute {
-    name: string;
-    page: string;
-    regex: string[];
-}
+import type { RequestData } from "../types/global";
 type EdgeRequest = Omit<RequestData, "page">;
 export default function edgeFunctionHandler(request: EdgeRequest): Promise<Response>;
 export {};

package/dist/core/patchAsyncStorage.js

@@ -1,16 +1,15 @@
-const mod = require("module");
+const mod = require("node:module");
 const resolveFilename = mod._resolveFilename;
 export function patchAsyncStorage() {
-    mod._resolveFilename = function (originalResolveFilename, request, parent, isMain, options) {
+    mod._resolveFilename = ((originalResolveFilename, request, parent, isMain, options) => {
         if (request.endsWith("static-generation-async-storage.external") ||
             request.endsWith("static-generation-async-storage.external.js")) {
             return require.resolve("./patchedAsyncStorage.cjs");
         }
-        else if (request.endsWith("static-generation-async-storage.external.original")) {
+        if (request.endsWith("static-generation-async-storage.external.original")) {
             return originalResolveFilename.call(mod, request.replace(".original", ".js"), parent, isMain, options);
         }
-        else
-            return originalResolveFilename.call(mod, request, parent, isMain, options);
+        return originalResolveFilename.call(mod, request, parent, isMain, options);
         // We use `bind` here to avoid referencing outside variables to create potential memory leaks.
-    }.bind(null, resolveFilename);
+    }).bind(null, resolveFilename);
 }

package/dist/core/requestHandler.js

@@ -1,65 +1,88 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
-import { DetachedPromiseRunner } from "../utils/promise";
+import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { convertRes, createServerResponse, proxyRequest } from "./routing/util";
-import routingHandler from "./routingHandler";
+import { convertRes, createServerResponse } from "./routing/util";
+import routingHandler, { MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
-globalThis.__als = new AsyncLocalStorage();
+globalThis.__openNextAls = new AsyncLocalStorage();
 patchAsyncStorage();
 export async function openNextHandler(internalEvent, responseStreaming) {
-    if (internalEvent.headers["x-forwarded-host"]) {
-        internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
-    }
-    debug("internalEvent", internalEvent);
-    //#override withRouting
-    let preprocessResult = {
-        internalEvent: internalEvent,
-        isExternalRewrite: false,
-        origin: false,
-        isISR: false,
-    };
-    try {
-        preprocessResult = await routingHandler(internalEvent);
-    }
-    catch (e) {
-        warn("Routing failed.", e);
-    }
-    //#endOverride
-    const headers = "type" in preprocessResult
-        ? preprocessResult.headers
-        : preprocessResult.internalEvent.headers;
-    const overwrittenResponseHeaders = Object.entries("type" in preprocessResult
-        ? preprocessResult.headers
-        : preprocessResult.internalEvent.headers).reduce((acc, [key, value]) => {
-        if (!key.startsWith("x-middleware-response-")) {
-            return acc;
+    // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
+    return runWithOpenNextRequestContext({ isISRRevalidation: internalEvent.headers["x-isr"] === "1" }, async () => {
+        if (internalEvent.headers["x-forwarded-host"]) {
+            internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
         }
-        else {
-            const newKey = key.replace("x-middleware-response-", "");
-            delete headers[key];
-            headers[newKey] = value;
-            return { ...acc, [newKey]: value };
+        debug("internalEvent", internalEvent);
+        let preprocessResult = {
+            internalEvent: internalEvent,
+            isExternalRewrite: false,
+            origin: false,
+            isISR: false,
+        };
+        //#override withRouting
+        try {
+            preprocessResult = await routingHandler(internalEvent);
+        }
+        catch (e) {
+            warn("Routing failed.", e);
         }
-    }, {});
-    if ("type" in preprocessResult) {
-        // // res is used only in the streaming case
-        if (responseStreaming) {
-            const res = createServerResponse(internalEvent, headers, responseStreaming);
-            res.statusCode = preprocessResult.statusCode;
-            res.flushHeaders();
-            const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
-            for await (const chunk of bodyToConsume) {
-                res.write(chunk);
+        //#endOverride
+        const headers = "type" in preprocessResult
+            ? preprocessResult.headers
+            : preprocessResult.internalEvent.headers;
+        const overwrittenResponseHeaders = {};
+        for (const [rawKey, value] of Object.entries(headers)) {
+            if (!rawKey.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+                continue;
             }
-            res.end();
-            preprocessResult.body = bodyToReturn;
+            const key = rawKey.slice(MIDDLEWARE_HEADER_PREFIX_LEN);
+            overwrittenResponseHeaders[key] = value;
+            headers[key] = value;
+            delete headers[rawKey];
+        }
+        if ("isExternalRewrite" in preprocessResult &&
+            preprocessResult.isExternalRewrite === true) {
+            try {
+                preprocessResult = await globalThis.proxyExternalRequest.proxy(preprocessResult.internalEvent);
+            }
+            catch (e) {
+                error("External request failed.", e);
+                preprocessResult = {
+                    internalEvent: {
+                        type: "core",
+                        rawPath: "/500",
+                        method: "GET",
+                        headers: {},
+                        url: "/500",
+                        query: {},
+                        cookies: {},
+                        remoteAddress: "",
+                    },
+                    // On error we need to rewrite to the 500 page which is an internal rewrite
+                    isExternalRewrite: false,
+                    isISR: false,
+                    origin: false,
+                };
+            }
+        }
+        if ("type" in preprocessResult) {
+            // response is used only in the streaming case
+            if (responseStreaming) {
+                const response = createServerResponse(internalEvent, headers, responseStreaming);
+                response.statusCode = preprocessResult.statusCode;
+                response.flushHeaders();
+                const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
+                for await (const chunk of bodyToConsume) {
+                    response.write(chunk);
+                }
+                response.end();
+                preprocessResult.body = bodyToReturn;
+            }
+            return preprocessResult;
         }
-        return preprocessResult;
-    }
-    else {
         const preprocessedEvent = preprocessResult.internalEvent;
         debug("preprocessedEvent", preprocessedEvent);
         const reqProps = {
@@ -74,58 +97,44 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             body: preprocessedEvent.body,
             remoteAddress: preprocessedEvent.remoteAddress,
         };
-        const requestId = Math.random().toString(36);
-        const pendingPromiseRunner = new DetachedPromiseRunner();
-        const isISRRevalidation = headers["x-isr"] === "1";
         const mergeHeadersPriority = globalThis.openNextConfig.dangerous
             ?.headersAndCookiesPriority
             ? globalThis.openNextConfig.dangerous.headersAndCookiesPriority(preprocessedEvent)
             : "middleware";
-        const internalResult = await globalThis.__als.run({
-            requestId,
-            pendingPromiseRunner,
-            isISRRevalidation,
-            mergeHeadersPriority,
-        }, async () => {
-            const preprocessedResult = preprocessResult;
-            const req = new IncomingMessage(reqProps);
-            const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
-            await processRequest(req, res, preprocessedEvent, preprocessedResult.isExternalRewrite);
-            const { statusCode, headers, isBase64Encoded, body } = convertRes(res);
-            const internalResult = {
-                type: internalEvent.type,
-                statusCode,
-                headers,
-                body,
-                isBase64Encoded,
-            };
+        const store = globalThis.__openNextAls.getStore();
+        if (store) {
+            store.mergeHeadersPriority = mergeHeadersPriority;
+        }
+        const req = new IncomingMessage(reqProps);
+        const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
+        await processRequest(req, res, preprocessedEvent);
+        const { statusCode, headers: responseHeaders, isBase64Encoded, body, } = convertRes(res);
+        const internalResult = {
+            type: internalEvent.type,
+            statusCode,
+            headers: responseHeaders,
+            body,
+            isBase64Encoded,
+        };
+        const requestId = store?.requestId;
+        if (requestId) {
             // reset lastModified. We need to do this to avoid memory leaks
             delete globalThis.lastModified[requestId];
-            await pendingPromiseRunner.await();
-            return internalResult;
-        });
+        }
         return internalResult;
-    }
+    });
 }
-async function processRequest(req, res, internalEvent, isExternalRewrite) {
+async function processRequest(req, res, internalEvent) {
     // @ts-ignore
     // Next.js doesn't parse body if the property exists
     // https://github.com/dougmoscrop/serverless-http/issues/227
     delete req.body;
     try {
-        // `serverHandler` is replaced at build time depending on user's
-        // nextjs version to patch Nextjs 13.4.x and future breaking changes.
-        const { rawPath } = internalEvent;
-        if (isExternalRewrite) {
-            return proxyRequest(internalEvent, res);
-        }
-        else {
-            //#override applyNextjsPrebundledReact
-            setNextjsPrebundledReact(rawPath);
-            //#endOverride
-            // Next Server
-            await requestHandler(req, res);
-        }
+        //#override applyNextjsPrebundledReact
+        setNextjsPrebundledReact(internalEvent.rawPath);
+        //#endOverride
+        // Next Server
+        await requestHandler(req, res);
     }
     catch (e) {
         // This might fail when using bundled next, importing won't do the trick either