handle multiple route

Author: conico974

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

@@ -2,6 +2,7 @@ import path from "node:path";
 
 import { debug } from "../logger";
 import {
+  loadAppPathRoutesManifest,
   loadAppPathsManifest,
   loadAppPathsManifestKeys,
   loadBuildId,
@@ -31,4 +32,6 @@ export const AppPathsManifestKeys =
   /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest =
   /* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);
-export const AppPathsManifest = loadAppPathsManifest(NEXT_DIR);
+export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
+export const AppPathRoutesManifest =
+  /* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);

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

@@ -89,6 +89,17 @@ export function loadAppPathsManifest(nextDir: string) {
   return JSON.parse(appPathsManifestJson) as Record<string, string>;
 }
 
+export function loadAppPathRoutesManifest(nextDir: string) {
+  const appPathRoutesManifestPath = path.join(
+    nextDir,
+    "app-path-routes-manifest.json",
+  );
+  const appPathRoutesManifestJson = fs.existsSync(appPathRoutesManifestPath)
+    ? fs.readFileSync(appPathRoutesManifestPath, "utf-8")
+    : "{}";
+  return JSON.parse(appPathRoutesManifestJson) as Record<string, string>;
+}
+
 export function loadAppPathsManifestKeys(nextDir: string) {
   const appPathsManifest = loadAppPathsManifest(nextDir);
   return Object.keys(appPathsManifest).map((key) => {

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

@@ -16,8 +16,7 @@ import {
 } from "../core/resolve";
 import routingHandler, {
   INTERNAL_HEADER_INITIAL_PATH,
-  INTERNAL_HEADER_RESOLVED_ROUTE,
-  INTERNAL_HEADER_ROUTE_TYPE,
+  INTERNAL_HEADER_RESOLVED_ROUTES,
 } from "../core/routingHandler";
 
 globalThis.internalFetch = fetch;
@@ -66,14 +65,15 @@ const defaultHandler = async (
               headers: {
                 ...result.internalEvent.headers,
                 [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
-                [INTERNAL_HEADER_RESOLVED_ROUTE]: result.resolvedRoute ?? "",
-                [INTERNAL_HEADER_ROUTE_TYPE]: result.routeType ?? "",
+                [INTERNAL_HEADER_RESOLVED_ROUTES]:
+                  JSON.stringify(result.resolvedRoutes) ?? "[]",
               },
             },
             isExternalRewrite: result.isExternalRewrite,
             origin,
             isISR: result.isISR,
             initialPath: result.initialPath,
+            resolvedRoutes: result.resolvedRoutes,
           };
         }
         try {
@@ -93,6 +93,7 @@ const defaultHandler = async (
             origin: false,
             isISR: result.isISR,
             initialPath: result.internalEvent.rawPath,
+            resolvedRoutes: [{ route: "/500", type: "page" }],
           };
         }
       }

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

@@ -5,7 +5,7 @@ import { IncomingMessage } from "http/index.js";
 import type {
   InternalEvent,
   InternalResult,
-  RouteType,
+  ResolvedRoute,
   RoutingResult,
   StreamCreator,
 } from "types/open-next";
@@ -16,8 +16,7 @@ import { patchAsyncStorage } from "./patchAsyncStorage";
 import { convertRes, createServerResponse } from "./routing/util";
 import routingHandler, {
   INTERNAL_HEADER_INITIAL_PATH,
-  INTERNAL_HEADER_RESOLVED_ROUTE,
-  INTERNAL_HEADER_ROUTE_TYPE,
+  INTERNAL_HEADER_RESOLVED_ROUTES,
   MIDDLEWARE_HEADER_PREFIX,
   MIDDLEWARE_HEADER_PREFIX_LEN,
 } from "./routingHandler";
@@ -41,15 +40,14 @@ export async function openNextHandler(
       }
       debug("internalEvent", internalEvent);
 
-      // These 3 will get overwritten by the routing handler if not using an external middleware
+      // These 2 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,
+        resolvedRoutes: internalEvent.headers[INTERNAL_HEADER_RESOLVED_ROUTES]
+          ? JSON.parse(internalEvent.headers[INTERNAL_HEADER_RESOLVED_ROUTES])
+          : ([] as ResolvedRoute[]),
       };
 
       let routingResult: InternalResult | RoutingResult = {
@@ -111,7 +109,7 @@ export async function openNextHandler(
             isISR: false,
             origin: false,
             initialPath: internalEvent.rawPath,
-            resolvedRoute: "/500",
+            resolvedRoutes: [{ route: "/500", type: "page" }],
           };
         }
       }

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

@@ -1,5 +1,5 @@
 import {
-  AppPathsManifest,
+  AppPathRoutesManifest,
   BuildId,
   ConfigHeaders,
   PrerenderManifest,
@@ -9,6 +9,7 @@ import type { RouteDefinition } from "types/next-types";
 import type {
   InternalEvent,
   InternalResult,
+  ResolvedRoute,
   RouteType,
   RoutingResult,
 } from "types/open-next";
@@ -27,8 +28,7 @@ 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 INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
 
 // Add the locale prefix to the regex so we correctly match the rawPath
@@ -57,31 +57,35 @@ export function routeMatcher(routeDefinitions: RouteDefinition[]) {
       ),
     };
   });
+
+  // We need to use AppPathRoutesManifest here
   const appPathsSet = new Set(
-    Object.keys(AppPathsManifest)
-      .filter((key) => key.endsWith("/page"))
-      // Remove the /page suffix
-      .map((key) => key.replace(/\/page$/, "")),
+    Object.entries(AppPathRoutesManifest)
+      .filter(([key, _]) => key.endsWith("page"))
+      .map(([_, value]) => value),
   );
   const routePathsSet = new Set(
-    Object.keys(AppPathsManifest)
-      .filter((key) => key.endsWith("/route"))
-      // Remove the /route suffix
-      .map((key) => key.replace(/\/route$/, "")),
+    Object.entries(AppPathRoutesManifest)
+      .filter(([key, _]) => key.endsWith("route"))
+      .map(([_, value]) => value),
   );
   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,
-      };
+    const foundRoutes = regexp.filter((route) => route.regexp.test(path));
+
+    if (foundRoutes.length > 0) {
+      return foundRoutes.map((foundRoute) => {
+        const routeType: RouteType | undefined = appPathsSet.has(
+          foundRoute.page,
+        )
+          ? "app"
+          : routePathsSet.has(foundRoute.page)
+            ? "route"
+            : "page";
+        return {
+          route: foundRoute.page,
+          type: routeType,
+        };
+      });
     }
     return false;
   };
@@ -265,27 +269,19 @@ export default async function routingHandler(
     ...nextHeaders,
   });
 
-  let resolvedRoute: string | undefined;
-  let routeType: RouteType | undefined;
+  const resolvedRoutes: ResolvedRoute[] = [
+    ...(Array.isArray(foundStaticRoute) ? foundStaticRoute : []),
+    ...(Array.isArray(foundDynamicRoute) ? foundDynamicRoute : []),
+  ];
 
-  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";
-  }
+  console.log("resolvedRoutes", resolvedRoutes);
 
   return {
     internalEvent,
     isExternalRewrite,
     origin: false,
     isISR,
     initialPath: event.rawPath,
-    resolvedRoute,
-    routeType,
+    resolvedRoutes,
   };
 }

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 {
+  loadAppPathRoutesManifest,
   loadAppPathsManifest,
   loadAppPathsManifestKeys,
   loadBuildId,
@@ -169,6 +170,7 @@ ${contents}
         const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
         const MiddlewareManifest = loadMiddlewareManifest(nextDir);
         const AppPathsManifest = loadAppPathsManifest(nextDir);
+        const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
 
         const contents = `
   import path from "node:path";
@@ -191,6 +193,8 @@ ${contents}
   export const AppPathsManifestKeys = ${JSON.stringify(AppPathsManifestKeys)};
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
   export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
+  export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+
 
   process.env.NEXT_BUILD_ID = BuildId;
 `;

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

@@ -109,6 +109,11 @@ export type IncludedConverter =
 
 export type RouteType = "route" | "page" | "app";
 
+export interface ResolvedRoute {
+  route: string;
+  type: RouteType;
+}
+
 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
@@ -119,10 +124,9 @@ export interface RoutingResult {
   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;
+
+  // The resolved route after applying rewrites, if used with an external middleware will be defined in x-opennext-resolved-routes header as a json encoded array
+  resolvedRoutes: ResolvedRoute[];
 }
 
 export interface MiddlewareResult