Feat: Allow overriding the proxying for external rewrite

packages/open-next/src/adapters/middleware.ts

@@ -1,11 +1,12 @@
 import type { InternalEvent, Origin } from "types/open-next";
 import { runWithOpenNextRequestContext } from "utils/promise";
 
-import { debug } from "../adapters/logger";
+import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import {
   resolveIncrementalCache,
   resolveOriginResolver,
+  resolveProxyRequest,
   resolveQueue,
   resolveTagCache,
 } from "../core/resolve";
@@ -19,6 +20,10 @@ const defaultHandler = async (internalEvent: InternalEvent) => {
     globalThis.openNextConfig.middleware?.originResolver,
   );
 
+  const externalRequestProxy = await resolveProxyRequest(
+    globalThis.openNextConfig.middleware?.override?.proxyExternalRequest,
+  );
+
   //#override includeCacheInMiddleware
   globalThis.tagCache = await resolveTagCache(
     globalThis.openNextConfig.middleware?.override?.tagCache,
@@ -40,17 +45,35 @@ const defaultHandler = async (internalEvent: InternalEvent) => {
       const result = await routingHandler(internalEvent);
       if ("internalEvent" in result) {
         debug("Middleware intercepted event", internalEvent);
-        let origin: Origin | false = false;
         if (!result.isExternalRewrite) {
-          origin = await originResolver.resolve(result.internalEvent.rawPath);
+          const origin = await originResolver.resolve(
+            result.internalEvent.rawPath,
+          );
+          return {
+            type: "middleware",
+            internalEvent: result.internalEvent,
+            isExternalRewrite: result.isExternalRewrite,
+            origin,
+            isISR: result.isISR,
+          };
+        }
+        try {
+          return externalRequestProxy.proxy(result.internalEvent);
+        } catch (e) {
+          error("External request failed.", e);
+          return {
+            type: "middleware",
+            internalEvent: {
+              ...result.internalEvent,
+              rawPath: "/500",
+              url: "/500",
+              method: "GET",
+            },
+            isExternalRewrite: result.isExternalRewrite,
+            origin: false,
+            isISR: result.isISR,
+          };
         }
-        return {
-          type: "middleware",
-          internalEvent: result.internalEvent,
-          isExternalRewrite: result.isExternalRewrite,
-          origin,
-          isISR: result.isISR,
-        };
       }
 
       debug("Middleware response", result);

packages/open-next/src/build/createMiddleware.ts

@@ -57,7 +57,10 @@ export async function createMiddleware(
       outfile: path.join(outputPath, "handler.mjs"),
       middlewareInfo,
       options,
-      overrides: config.middleware?.override,
+      overrides: {
+        ...config.middleware.override,
+        originResolver: config.middleware.originResolver,
+      },
       defaultConverter: "aws-cloudfront",
       includeCache: config.dangerous?.enableCacheInterception,
       additionalExternals: config.edgeExternals,

packages/open-next/src/build/edge/createEdgeBundle.ts

@@ -6,11 +6,14 @@ import { build } from "esbuild";
 import type { MiddlewareInfo, MiddlewareManifest } from "types/next-types";
 import type {
   IncludedConverter,
+  IncludedOriginResolver,
+  LazyLoadedOverride,
   OverrideOptions,
   RouteTemplate,
   SplittedFunctionOptions,
 } from "types/open-next";
 
+import type { OriginResolver } from "types/overrides.js";
 import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
@@ -23,7 +26,11 @@ interface BuildEdgeBundleOptions {
   entrypoint: string;
   outfile: string;
   options: BuildOptions;
-  overrides?: OverrideOptions;
+  overrides?: OverrideOptions & {
+    originResolver?:
+      | LazyLoadedOverride<OriginResolver>
+      | IncludedOriginResolver;
+  };
   defaultConverter?: IncludedConverter;
   additionalInject?: string;
   includeCache?: boolean;
@@ -84,6 +91,10 @@ export async function buildEdgeBundle({
                       : "sqs-lite",
                 }
               : {}),
+            originResolver:
+              typeof overrides?.originResolver === "string"
+                ? overrides.originResolver
+                : "pattern-env",
           },
           fnName: name,
         }),

packages/open-next/src/build/validateConfig.ts

@@ -18,6 +18,7 @@ const compatibilityMatrix: Record<IncludedWrapper, IncludedConverter[]> = {
   "aws-lambda-streaming": ["aws-apigw-v2"],
   cloudflare: ["edge"],
   node: ["node"],
+  dummy: [],
 };
 
 function validateFunctionOptions(fnOptions: FunctionOptions) {

packages/open-next/src/core/createMainHandler.ts

@@ -6,6 +6,7 @@ import { openNextHandler } from "./requestHandler";
 import {
   resolveConverter,
   resolveIncrementalCache,
+  resolveProxyRequest,
   resolveQueue,
   resolveTagCache,
   resolveWrapper,
@@ -33,6 +34,10 @@ export async function createMainHandler() {
 
   globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
 
+  globalThis.proxyExternalRequest = await resolveProxyRequest(
+    thisFunction.override?.proxyExternalRequest,
+  );
+
   globalThis.lastModified = {};
 
   // From the config, we create the converter

packages/open-next/src/core/requestHandler.ts

@@ -7,7 +7,8 @@ import { runWithOpenNextRequestContext } from "utils/promise";
 
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { convertRes, createServerResponse, proxyRequest } from "./routing/util";
+import { resolveProxyRequest } from "./resolve";
+import { convertRes, createServerResponse } from "./routing/util";
 import type { MiddlewareOutputEvent } from "./routingHandler";
 import routingHandler, {
   MIDDLEWARE_HEADER_PREFIX,
@@ -65,6 +66,34 @@ export async function openNextHandler(
         delete headers[rawKey];
       }
 
+      if (
+        "isExternalRewrite" in preprocessResult &&
+        preprocessResult.isExternalRewrite
+      ) {
+        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: "",
+            },
+            isExternalRewrite: false,
+            isISR: false,
+            origin: false,
+          };
+        }
+      }
+
       if ("type" in preprocessResult) {
         // response is used only in the streaming case
         if (responseStreaming) {
@@ -110,20 +139,14 @@ export async function openNextHandler(
         store.mergeHeadersPriority = mergeHeadersPriority;
       }
 
-      const preprocessedResult = preprocessResult as MiddlewareOutputEvent;
       const req = new IncomingMessage(reqProps);
       const res = createServerResponse(
         preprocessedEvent,
         overwrittenResponseHeaders,
         responseStreaming,
       );
 
-      await processRequest(
-        req,
-        res,
-        preprocessedEvent,
-        preprocessedResult.isExternalRewrite,
-      );
+      await processRequest(req, res, preprocessedEvent);
 
       const {
         statusCode,
@@ -155,21 +178,13 @@ async function processRequest(
   req: IncomingMessage,
   res: OpenNextNodeResponse,
   internalEvent: InternalEvent,
-  isExternalRewrite?: boolean,
 ) {
   // @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.
-
-    if (isExternalRewrite) {
-      return proxyRequest(internalEvent, res);
-    }
-
     //#override applyNextjsPrebundledReact
     setNextjsPrebundledReact(internalEvent.rawPath);
     //#endOverride

packages/open-next/src/core/resolve.ts

@@ -3,17 +3,13 @@ import type {
   DefaultOverrideOptions,
   InternalEvent,
   InternalResult,
-  LazyLoadedOverride,
+  OpenNextConfig,
   OverrideOptions,
 } from "types/open-next";
-import type {
-  Converter,
-  ImageLoader,
-  OriginResolver,
-  TagCache,
-  Warmer,
-  Wrapper,
-} from "types/overrides";
+import type { Converter, TagCache, Wrapper } from "types/overrides";
+
+// Just a little utility type to remove undefined from a type
+type RemoveUndefined<T> = T extends undefined ? never : T;
 
 export async function resolveConverter<
   E extends BaseEventOrResult = InternalEvent,
@@ -95,7 +91,7 @@ export async function resolveIncrementalCache(
  * @__PURE__
  */
 export async function resolveImageLoader(
-  imageLoader: LazyLoadedOverride<ImageLoader> | string,
+  imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"],
 ) {
   if (typeof imageLoader === "function") {
     return imageLoader();
@@ -109,7 +105,9 @@ export async function resolveImageLoader(
  * @__PURE__
  */
 export async function resolveOriginResolver(
-  originResolver?: LazyLoadedOverride<OriginResolver> | string,
+  originResolver: RemoveUndefined<
+    OpenNextConfig["middleware"]
+  >["originResolver"],
 ) {
   if (typeof originResolver === "function") {
     return originResolver();
@@ -122,11 +120,24 @@ export async function resolveOriginResolver(
  * @__PURE__
  */
 export async function resolveWarmerInvoke(
-  warmer?: LazyLoadedOverride<Warmer> | "aws-lambda",
+  warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"],
 ) {
   if (typeof warmer === "function") {
     return warmer();
   }
   const m_1 = await import("../overrides/warmer/aws-lambda.js");
   return m_1.default;
 }
+
+/**
+ * @__PURE__
+ */
+export async function resolveProxyRequest(
+  proxyRequest: OverrideOptions["proxyExternalRequest"],
+) {
+  if (typeof proxyRequest === "function") {
+    return proxyRequest();
+  }
+  const m_1 = await import("../overrides/proxyExternalRequest/node.js");
+  return m_1.default;
+}