add additional metadata to RoutingResult

packages/open-next/src/adapters/config/index.ts

@@ -2,14 +2,14 @@ import path from "node:path";
 
 import { debug } from "../logger";
 import {
+  loadAppPathsManifest,
   loadAppPathsManifestKeys,
   loadBuildId,
   loadConfig,
   loadConfigHeaders,
   loadHtmlPages,
   loadMiddlewareManifest,
   loadPrerenderManifest,
-  // loadPublicAssets,
   loadRoutesManifest,
 } from "./util.js";
 
@@ -31,3 +31,4 @@ export const AppPathsManifestKeys =
   /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest =
   /* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);
+export const AppPathsManifest = loadAppPathsManifest(NEXT_DIR);

packages/open-next/src/adapters/config/util.ts

@@ -77,7 +77,7 @@ export function loadPrerenderManifest(nextDir: string) {
   return JSON.parse(json) as PrerenderManifest;
 }
 
-export function loadAppPathsManifestKeys(nextDir: string) {
+export function loadAppPathsManifest(nextDir: string) {
   const appPathsManifestPath = path.join(
     nextDir,
     "server",
@@ -86,10 +86,11 @@ export function loadAppPathsManifestKeys(nextDir: string) {
   const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
     ? fs.readFileSync(appPathsManifestPath, "utf-8")
     : "{}";
-  const appPathsManifest = JSON.parse(appPathsManifestJson) as Record<
-    string,
-    string
-  >;
+  return JSON.parse(appPathsManifestJson) as Record<string, string>;
+}
+
+export function loadAppPathsManifestKeys(nextDir: string) {
+  const appPathsManifest = loadAppPathsManifest(nextDir);
   return Object.keys(appPathsManifest).map((key) => {
     // Remove parallel route
     let cleanedKey = key.replace(/\/@[^\/]+/g, "");

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

@@ -14,7 +14,11 @@ import {
   resolveQueue,
   resolveTagCache,
 } from "../core/resolve";
-import routingHandler from "../core/routingHandler";
+import routingHandler, {
+  INTERNAL_HEADER_INITIAL_PATH,
+  INTERNAL_HEADER_RESOLVED_ROUTE,
+  INTERNAL_HEADER_ROUTE_TYPE,
+} from "../core/routingHandler";
 
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
@@ -57,10 +61,19 @@ const defaultHandler = async (
           );
           return {
             type: "middleware",
-            internalEvent: result.internalEvent,
+            internalEvent: {
+              ...result.internalEvent,
+              headers: {
+                ...result.internalEvent.headers,
+                [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
+                [INTERNAL_HEADER_RESOLVED_ROUTE]: result.resolvedRoute ?? "",
+                [INTERNAL_HEADER_ROUTE_TYPE]: result.routeType ?? "",
+              },
+            },
             isExternalRewrite: result.isExternalRewrite,
             origin,
             isISR: result.isISR,
+            initialPath: result.initialPath,
           };
         }
         try {
@@ -79,6 +92,7 @@ const defaultHandler = async (
             isExternalRewrite: false,
             origin: false,
             isISR: result.isISR,
+            initialPath: result.internalEvent.rawPath,
           };
         }
       }

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

@@ -5,6 +5,7 @@ import { IncomingMessage } from "http/index.js";
 import type {
   InternalEvent,
   InternalResult,
+  RouteType,
   RoutingResult,
   StreamCreator,
 } from "types/open-next";
@@ -14,6 +15,9 @@ import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { convertRes, createServerResponse } from "./routing/util";
 import routingHandler, {
+  INTERNAL_HEADER_INITIAL_PATH,
+  INTERNAL_HEADER_RESOLVED_ROUTE,
+  INTERNAL_HEADER_ROUTE_TYPE,
   MIDDLEWARE_HEADER_PREFIX,
   MIDDLEWARE_HEADER_PREFIX_LEN,
 } from "./routingHandler";
@@ -37,11 +41,23 @@ export async function openNextHandler(
       }
       debug("internalEvent", internalEvent);
 
+      // These 3 will get overwritten by the routing handler if not using an external middleware
+      const internalHeaders = {
+        initialPath:
+          internalEvent.headers[INTERNAL_HEADER_INITIAL_PATH] ??
+          internalEvent.rawPath,
+        resolvedRoute: internalEvent.headers[INTERNAL_HEADER_RESOLVED_ROUTE],
+        routeType: internalEvent.headers[INTERNAL_HEADER_ROUTE_TYPE] as
+          | RouteType
+          | undefined,
+      };
+
       let routingResult: InternalResult | RoutingResult = {
         internalEvent,
         isExternalRewrite: false,
         origin: false,
         isISR: false,
+        ...internalHeaders,
       };
 
       //#override withRouting
@@ -94,6 +110,8 @@ export async function openNextHandler(
             isExternalRewrite: false,
             isISR: false,
             origin: false,
+            initialPath: internalEvent.rawPath,
+            resolvedRoute: "/500",
           };
         }
       }

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

@@ -1,12 +1,15 @@
 import {
+  AppPathsManifest,
   BuildId,
   ConfigHeaders,
   PrerenderManifest,
   RoutesManifest,
 } from "config/index";
+import type { RouteDefinition } from "types/next-types";
 import type {
   InternalEvent,
   InternalResult,
+  RouteType,
   RoutingResult,
 } from "types/open-next";
 
@@ -22,6 +25,10 @@ import {
 import { handleMiddleware } from "./routing/middleware";
 
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
+export const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export const INTERNAL_HEADER_INITIAL_PATH = `${INTERNAL_HEADER_PREFIX}initial-path`;
+export const INTERNAL_HEADER_RESOLVED_ROUTE = `${INTERNAL_HEADER_PREFIX}resolved-route`;
+export const INTERNAL_HEADER_ROUTE_TYPE = `${INTERNAL_HEADER_PREFIX}route-type`;
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
 
 // Add the locale prefix to the regex so we correctly match the rawPath
@@ -39,23 +46,49 @@ const apiPrefix = RoutesManifest.basePath
   ? `${RoutesManifest.basePath}/api`
   : "/api";
 
-const staticRegexp = RoutesManifest.routes.static.map(
-  (route) =>
-    new RegExp(
-      route.regex
-        .replace("^/", optionalLocalePrefixRegex)
-        .replace("^/", optionalBasepathPrefixRegex),
-    ),
-);
-
-const dynamicRegexp = RoutesManifest.routes.dynamic.map(
-  (route) =>
-    new RegExp(
-      route.regex
-        .replace("^/", optionalLocalePrefixRegex)
-        .replace("^/", optionalBasepathPrefixRegex),
-    ),
-);
+export function routeMatcher(routeDefinitions: RouteDefinition[]) {
+  const regexp = routeDefinitions.map((route) => {
+    return {
+      page: route.page,
+      regexp: new RegExp(
+        route.regex
+          .replace("^/", optionalLocalePrefixRegex)
+          .replace("^/", optionalBasepathPrefixRegex),
+      ),
+    };
+  });
+  const appPathsSet = new Set(
+    Object.keys(AppPathsManifest)
+      .filter((key) => key.endsWith("/page"))
+      // Remove the /page suffix
+      .map((key) => key.replace(/\/page$/, "")),
+  );
+  const routePathsSet = new Set(
+    Object.keys(AppPathsManifest)
+      .filter((key) => key.endsWith("/route"))
+      // Remove the /route suffix
+      .map((key) => key.replace(/\/route$/, "")),
+  );
+  return function matchRoute(path: string) {
+    const foundRoute = regexp.find((route) => route.regexp.test(path));
+    let routeType: RouteType | undefined = undefined;
+    if (foundRoute) {
+      routeType = appPathsSet.has(foundRoute.page)
+        ? "app"
+        : routePathsSet.has(foundRoute.page)
+          ? "route"
+          : "page";
+      return {
+        page: foundRoute.page,
+        routeType,
+      };
+    }
+    return false;
+  };
+}
+
+const staticRouteMatcher = routeMatcher(RoutesManifest.routes.static);
+const dynamicRouteMatcher = routeMatcher(RoutesManifest.routes.dynamic);
 
 // Geolocation headers starting from Nextjs 15
 // See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
@@ -95,6 +128,17 @@ export default async function routingHandler(
     }
   }
 
+  // First we remove internal headers
+  // We don't want to allow users to set these headers
+  for (const key of Object.keys(event.headers)) {
+    if (
+      key.startsWith(INTERNAL_HEADER_PREFIX) ||
+      key.startsWith(MIDDLEWARE_HEADER_PREFIX)
+    ) {
+      delete event.headers[key];
+    }
+  }
+
   const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
 
   let internalEvent = fixDataPage(event, BuildId);
@@ -127,12 +171,8 @@ export default async function routingHandler(
     internalEvent = beforeRewrites.internalEvent;
     isExternalRewrite = beforeRewrites.isExternalRewrite;
   }
-
-  const isStaticRoute =
-    !isExternalRewrite &&
-    staticRegexp.some((route) =>
-      route.test((internalEvent as InternalEvent).rawPath),
-    );
+  const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+  const isStaticRoute = !isExternalRewrite && Boolean(foundStaticRoute);
 
   if (!isStaticRoute && !isExternalRewrite) {
     // Second rewrite to be applied
@@ -151,12 +191,10 @@ export default async function routingHandler(
   );
   internalEvent = fallbackEvent;
 
-  const isDynamicRoute =
-    !isExternalRewrite &&
-    dynamicRegexp.some((route) =>
-      route.test((internalEvent as InternalEvent).rawPath),
-    );
-  if (!isDynamicRoute && !isStaticRoute && !isExternalRewrite) {
+  const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+  const isDynamicRoute = !isExternalRewrite && Boolean(foundDynamicRoute);
+
+  if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
     // Fallback rewrite to be applied
     const fallbackRewrites = handleRewrites(
       internalEvent,
@@ -181,15 +219,13 @@ export default async function routingHandler(
   // If we still haven't found a route, we show the 404 page
   // We need to ensure that rewrites are applied before showing the 404 page
   if (
-    !isRouteFoundBeforeAllRewrites &&
-    !isApiRoute &&
-    !isNextImageRoute &&
-    // We need to check again once all rewrites have been applied
-    !staticRegexp.some((route) =>
-      route.test((internalEvent as InternalEvent).rawPath),
-    ) &&
-    !dynamicRegexp.some((route) =>
-      route.test((internalEvent as InternalEvent).rawPath),
+    !(
+      isRouteFoundBeforeAllRewrites ||
+      isApiRoute ||
+      isNextImageRoute ||
+      // We need to check again once all rewrites have been applied
+      staticRouteMatcher(internalEvent.rawPath) ||
+      dynamicRouteMatcher(internalEvent.rawPath)
     )
   ) {
     internalEvent = {
@@ -229,10 +265,27 @@ export default async function routingHandler(
     ...nextHeaders,
   });
 
+  let resolvedRoute: string | undefined;
+  let routeType: RouteType | undefined;
+
+  if (foundStaticRoute) {
+    resolvedRoute = foundStaticRoute.page;
+    routeType = foundStaticRoute.routeType;
+  } else if (foundDynamicRoute) {
+    resolvedRoute = foundDynamicRoute.page;
+    routeType = foundDynamicRoute.routeType;
+  } else if (isApiRoute) {
+    // For /api paths we assume that they're route types
+    routeType = "route";
+  }
+
   return {
     internalEvent,
     isExternalRewrite,
     origin: false,
     isISR,
+    initialPath: event.rawPath,
+    resolvedRoute,
+    routeType,
   };
 }

packages/open-next/src/plugins/edge.ts

@@ -6,6 +6,7 @@ import type { Plugin } from "esbuild";
 import type { MiddlewareInfo } from "types/next-types.js";
 
 import {
+  loadAppPathsManifest,
   loadAppPathsManifestKeys,
   loadBuildId,
   loadConfig,
@@ -167,6 +168,7 @@ ${contents}
         const PrerenderManifest = loadPrerenderManifest(nextDir);
         const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
         const MiddlewareManifest = loadMiddlewareManifest(nextDir);
+        const AppPathsManifest = loadAppPathsManifest(nextDir);
 
         const contents = `
   import path from "node:path";
@@ -188,6 +190,7 @@ ${contents}
   export const PrerenderManifest = ${JSON.stringify(PrerenderManifest)};
   export const AppPathsManifestKeys = ${JSON.stringify(AppPathsManifestKeys)};
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
+  export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
 
   process.env.NEXT_BUILD_ID = BuildId;
 `;

packages/open-next/src/types/open-next.ts

@@ -107,11 +107,22 @@ export type IncludedConverter =
   | "sqs-revalidate"
   | "dummy";
 
+export type RouteType = "route" | "page" | "app";
+
 export interface RoutingResult {
   internalEvent: InternalEvent;
+  // If the request is an external rewrite, if used with an external middleware will be false on every server function
   isExternalRewrite: boolean;
+  // Origin is only used in external middleware, will be false on every server function
   origin: Origin | false;
+  // If the request is for an ISR route, will be false on every server function. Only used in external middleware
   isISR: boolean;
+  // The initial rawPath of the request before applying rewrites, if used with an external middleware will be defined in x-opennext-initial-path header
+  initialPath: string;
+  // The resolved route after applying rewrites, if used with an external middleware will be defined in x-opennext-resolved-route header
+  resolvedRoute?: string;
+  // The type of the resolved route, if used with an external middleware will be defined in x-opennext-route-type header
+  routeType?: RouteType;
 }
 
 export interface MiddlewareResult