fixup! MiddlewareOutputEvent

Author: vicb

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

@@ -34,25 +34,26 @@ export async function openNextHandler(
       }
       debug("internalEvent", internalEvent);
 
-      let preprocessResult: InternalResult | MiddlewareOutputEvent = {
-        internalEvent: internalEvent,
+      let routingResult: InternalResult | MiddlewareOutputEvent = {
+        type: "middleware",
+        internalEvent,
         isExternalRewrite: false,
         origin: false,
         isISR: false,
       };
 
       //#override withRouting
       try {
-        preprocessResult = await routingHandler(internalEvent);
+        routingResult = await routingHandler(internalEvent);
       } catch (e) {
         warn("Routing failed.", e);
       }
       //#endOverride
 
       const headers =
-        "type" in preprocessResult
-          ? preprocessResult.headers
-          : preprocessResult.internalEvent.headers;
+        routingResult.type === "middleware"
+          ? routingResult.internalEvent.headers
+          : routingResult.headers;
 
       const overwrittenResponseHeaders: Record<string, string | string[]> = {};
 
@@ -67,16 +68,17 @@ export async function openNextHandler(
       }
 
       if (
-        "isExternalRewrite" in preprocessResult &&
-        preprocessResult.isExternalRewrite === true
+        routingResult.type === "middleware" &&
+        routingResult.isExternalRewrite === true
       ) {
         try {
-          preprocessResult = await globalThis.proxyExternalRequest.proxy(
-            preprocessResult.internalEvent,
+          routingResult = await globalThis.proxyExternalRequest.proxy(
+            routingResult.internalEvent,
           );
         } catch (e) {
           error("External request failed.", e);
-          preprocessResult = {
+          routingResult = {
+            type: "middleware",
             internalEvent: {
               type: "core",
               rawPath: "/500",
@@ -95,26 +97,27 @@ export async function openNextHandler(
         }
       }
 
-      if ("type" in preprocessResult) {
+      if (routingResult.type === "core") {
         // response is used only in the streaming case
         if (responseStreaming) {
           const response = createServerResponse(
             internalEvent,
             headers,
             responseStreaming,
           );
-          response.statusCode = preprocessResult.statusCode;
+          response.statusCode = routingResult.statusCode;
           response.flushHeaders();
-          const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
+          const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
           for await (const chunk of bodyToConsume) {
             response.write(chunk);
           }
           response.end();
-          preprocessResult.body = bodyToReturn;
+          routingResult.body = bodyToReturn;
         }
-        return preprocessResult;
+        return routingResult;
       }
-      const preprocessedEvent = preprocessResult.internalEvent;
+
+      const preprocessedEvent = routingResult.internalEvent;
       debug("preprocessedEvent", preprocessedEvent);
       const reqProps = {
         method: preprocessedEvent.method,

packages/open-next/src/core/routing/middleware.ts

@@ -23,9 +23,9 @@ const middlewareManifest = MiddlewareManifest;
 
 const middleMatch = getMiddlewareMatch(middlewareManifest);
 
-type MiddlewareOutputEvent = InternalEvent & {
+type InternalMiddlewareEvent = InternalEvent & {
   responseHeaders?: Record<string, string | string[]>;
-  externalRewrite?: boolean;
+  isExternalRewrite?: boolean;
 };
 
 type Middleware = (request: Request) => Response | Promise<Response>;
@@ -45,7 +45,7 @@ function defaultMiddlewareLoader() {
 export async function handleMiddleware(
   internalEvent: InternalEvent,
   middlewareLoader: MiddlewareLoader = defaultMiddlewareLoader,
-): Promise<MiddlewareOutputEvent | InternalResult> {
+): Promise<InternalMiddlewareEvent | InternalResult> {
   const headers = internalEvent.headers;
 
   // We bypass the middleware if the request is internal
@@ -142,22 +142,22 @@ export async function handleMiddleware(
       statusCode: statusCode,
       headers: resHeaders,
       isBase64Encoded: false,
-    };
+    } satisfies InternalResult;
   }
 
   // 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");
   let rewritten = false;
-  let externalRewrite = false;
+  let isExternalRewrite = false;
   let middlewareQueryString = internalEvent.query;
   let newUrl = internalEvent.url;
   if (rewriteUrl) {
     // If not a string, it should probably throw
     if (isExternal(rewriteUrl, internalEvent.headers.host as string)) {
       newUrl = rewriteUrl;
       rewritten = true;
-      externalRewrite = true;
+      isExternalRewrite = true;
     } else {
       const rewriteUrlObject = new URL(rewriteUrl);
       newUrl = rewriteUrlObject.pathname;
@@ -184,14 +184,13 @@ export async function handleMiddleware(
     // transfer response body to res
     const body = result.body as ReadableStream<Uint8Array>;
 
-    // await pipeReadable(result.response.body, res);
     return {
       type: internalEvent.type,
       statusCode: statusCode,
       headers: resHeaders,
       body,
       isBase64Encoded: false,
-    };
+    } satisfies InternalResult;
   }
 
   return {
@@ -207,6 +206,6 @@ export async function handleMiddleware(
     query: middlewareQueryString,
     cookies: internalEvent.cookies,
     remoteAddress: internalEvent.remoteAddress,
-    externalRewrite,
-  };
+    isExternalRewrite,
+  } satisfies InternalMiddlewareEvent;
 }

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

@@ -19,7 +19,9 @@ import { handleMiddleware } from "./routing/middleware";
 
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
+
 export interface MiddlewareOutputEvent {
+  type: "middleware";
   internalEvent: InternalEvent;
   isExternalRewrite: boolean;
   origin: Origin | false;
@@ -110,17 +112,16 @@ export default async function routingHandler(
     return redirect;
   }
 
-  const middleware = await handleMiddleware(internalEvent);
-  let middlewareResponseHeaders: Record<string, string | string[]> = {};
-  if ("statusCode" in middleware) {
-    return middleware;
+  const middlewareEventOrResult = await handleMiddleware(internalEvent);
+  const isInternalResult = "statusCode" in middlewareEventOrResult;
+  if (isInternalResult) {
+    return middlewareEventOrResult;
   }
-  middlewareResponseHeaders = middleware.responseHeaders || {};
-  internalEvent = middleware;
-
-  // At this point internalEvent is an InternalEvent or a MiddlewareOutputEvent
+  const middlewareResponseHeaders = middlewareEventOrResult.responseHeaders;
+  let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
+  // internalEvent is `InternalEvent | InternalMiddlewareEvent`
+  internalEvent = middlewareEventOrResult;
 
-  let isExternalRewrite = middleware.externalRewrite ?? false;
   if (!isExternalRewrite) {
     // First rewrite to be applied
     const beforeRewrites = handleRewrites(
@@ -233,6 +234,7 @@ export default async function routingHandler(
   });
 
   return {
+    type: "middleware",
     internalEvent,
     isExternalRewrite,
     origin: false,

packages/open-next/src/overrides/converters/aws-cloudfront.ts

@@ -111,10 +111,6 @@ async function convertFromCloudFrontRequestEvent(
   };
 }
 
-type MiddlewareEvent = {
-  type: "middleware";
-} & MiddlewareOutputEvent;
-
 function convertToCloudfrontHeaders(
   headers: Record<string, OutgoingHttpHeader>,
   directResponse?: boolean,
@@ -150,7 +146,7 @@ function convertToCloudfrontHeaders(
 }
 
 async function convertToCloudFrontRequestResult(
-  result: InternalResult | MiddlewareEvent,
+  result: InternalResult | MiddlewareOutputEvent,
   originalRequest: CloudFrontRequestEvent,
 ): Promise<CloudFrontRequestResult> {
   if (result.type === "middleware") {

packages/open-next/src/overrides/wrappers/cloudflare-streaming.ts

@@ -3,7 +3,6 @@ import type { Wrapper, WrapperHandler } from "types/overrides";
 
 import { Writable } from "node:stream";
 import type { StreamCreator } from "http/index";
-import type { MiddlewareOutputEvent } from "../../core/routingHandler";
 
 const handler: WrapperHandler<InternalEvent, InternalResult> =
   async (handler, converter) =>

packages/open-next/src/overrides/wrappers/cloudflare.ts

@@ -17,7 +17,7 @@ interface WorkerContext {
 
 const handler: WrapperHandler<
   InternalEvent,
-  InternalResult | ({ type: "middleware" } & MiddlewareOutputEvent)
+  InternalResult | MiddlewareOutputEvent
 > =
   async (handler, converter) =>
   async (
@@ -65,7 +65,4 @@ export default {
   name: "cloudflare",
   supportStreaming: true,
   edgeRuntime: true,
-} satisfies Wrapper<
-  InternalEvent,
-  InternalResult | ({ type: "middleware" } & MiddlewareOutputEvent)
->;
+} satisfies Wrapper<InternalEvent, InternalResult | MiddlewareOutputEvent>;