@opennextjs/aws 3.3.0 → 3.3.1

package/dist/adapters/cache.d.ts

@@ -58,8 +58,7 @@ interface CacheHandlerValue {
     cacheState?: string;
     value: IncrementalCacheValue | null;
 }
-export declare function hasCacheExtension(key: string): boolean;
-export default class S3Cache {
+export default class Cache {
     get(key: string, options?: boolean | {
         fetchCache?: boolean;
         kindHint?: "app" | "pages" | "fetch";

package/dist/adapters/cache.js

@@ -1,10 +1,5 @@
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
-/** Beginning single backslash is intentional, to look for the dot + the extension. Do not escape it again. */
-const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
-export function hasCacheExtension(key) {
-    return CACHE_EXTENSION_REGEX.test(key);
-}
 function isFetchCache(options) {
     if (typeof options === "boolean") {
         return options;
@@ -17,7 +12,7 @@ function isFetchCache(options) {
     return false;
 }
 // We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
-export default class S3Cache {
+export default class Cache {
     async get(key, 
     // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
     options) {
@@ -34,7 +29,6 @@ export default class S3Cache {
         debug("get fetch cache", { key, softTags, tags });
         try {
             const { value, lastModified } = await globalThis.incrementalCache.get(key, true);
-            // const { Body, LastModified } = await this.getS3Object(key, "fetch");
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {
                 // If some tags are stale we need to force revalidation
@@ -71,10 +65,6 @@ export default class S3Cache {
     async getIncrementalCache(key) {
         try {
             const { value: cacheData, lastModified } = await globalThis.incrementalCache.get(key, false);
-            // const { Body, LastModified } = await this.getS3Object(key, "cache");
-            // const cacheData = JSON.parse(
-            //   (await Body?.transformToString()) ?? "{}",
-            // ) as S3CachedFile;
             const meta = cacheData?.meta;
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {

package/dist/adapters/config/index.d.ts

@@ -25,3 +25,5 @@ export declare const ConfigHeaders: import("../../types/next-types").Header[] |
 export declare const PrerenderManifest: import("../../types/next-types").PrerenderManifest;
 export declare const AppPathsManifestKeys: string[];
 export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;
+export declare const AppPathsManifest: Record<string, string>;
+export declare const AppPathRoutesManifest: Record<string, string>;

package/dist/adapters/config/index.js

@@ -1,8 +1,6 @@
 import path from "node:path";
 import { debug } from "../logger";
-import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, 
-// loadPublicAssets,
-loadRoutesManifest, } from "./util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
 export const NEXT_DIR = path.join(__dirname, ".next");
 export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
 debug({ NEXT_DIR, OPEN_NEXT_DIR });
@@ -19,3 +17,6 @@ export const AppPathsManifestKeys =
 /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest = 
 /* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);
+export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
+export const AppPathRoutesManifest = 
+/* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);

package/dist/adapters/config/util.d.ts

@@ -24,5 +24,7 @@ export declare function loadRoutesManifest(nextDir: string): {
 };
 export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types").Header[] | undefined;
 export declare function loadPrerenderManifest(nextDir: string): PrerenderManifest;
+export declare function loadAppPathsManifest(nextDir: string): Record<string, string>;
+export declare function loadAppPathRoutesManifest(nextDir: string): Record<string, string>;
 export declare function loadAppPathsManifestKeys(nextDir: string): string[];
 export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;

package/dist/adapters/config/util.js

@@ -60,12 +60,22 @@ export function loadPrerenderManifest(nextDir) {
     const json = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(json);
 }
-export function loadAppPathsManifestKeys(nextDir) {
+export function loadAppPathsManifest(nextDir) {
     const appPathsManifestPath = path.join(nextDir, "server", "app-paths-manifest.json");
     const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
         ? fs.readFileSync(appPathsManifestPath, "utf-8")
         : "{}";
-    const appPathsManifest = JSON.parse(appPathsManifestJson);
+    return JSON.parse(appPathsManifestJson);
+}
+export function loadAppPathRoutesManifest(nextDir) {
+    const appPathRoutesManifestPath = path.join(nextDir, "app-path-routes-manifest.json");
+    if (fs.existsSync(appPathRoutesManifestPath)) {
+        return JSON.parse(fs.readFileSync(appPathRoutesManifestPath, "utf-8"));
+    }
+    return {};
+}
+export function loadAppPathsManifestKeys(nextDir) {
+    const appPathsManifest = loadAppPathsManifest(nextDir);
     return Object.keys(appPathsManifest).map((key) => {
         // Remove parallel route
         let cleanedKey = key.replace(/\/@[^\/]+/g, "");

package/dist/adapters/middleware.js

@@ -2,7 +2,7 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
-import routingHandler from "../core/routingHandler";
+import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent) => {
@@ -22,10 +22,19 @@ const defaultHandler = async (internalEvent) => {
                 const origin = await originResolver.resolve(result.internalEvent.rawPath);
                 return {
                     type: "middleware",
-                    internalEvent: result.internalEvent,
+                    internalEvent: {
+                        ...result.internalEvent,
+                        headers: {
+                            ...result.internalEvent.headers,
+                            [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
+                            [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes) ?? "[]",
+                        },
+                    },
                     isExternalRewrite: result.isExternalRewrite,
                     origin,
                     isISR: result.isISR,
+                    initialPath: result.initialPath,
+                    resolvedRoutes: result.resolvedRoutes,
                 };
             }
             try {
@@ -45,6 +54,8 @@ const defaultHandler = async (internalEvent) => {
                     isExternalRewrite: false,
                     origin: false,
                     isISR: result.isISR,
+                    initialPath: result.internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }

package/dist/adapters/util.js

@@ -1,6 +1,10 @@
 //TODO: We should probably move all the utils to a separate location
 export function setNodeEnv() {
-    process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
+    // Note: we create a `processEnv` variable instead of just using `process.env` directly
+    //       because build tools can substitute `process.env.NODE_ENV` on build making
+    //       assignments such as `process.env.NODE_ENV = ...` problematic
+    const processEnv = process.env;
+    processEnv.NODE_ENV = process.env.NODE_ENV ?? "production";
 }
 export function generateUniqueId() {
     return Math.random().toString(36).slice(2, 8);

package/dist/build/createAssets.js

@@ -109,10 +109,29 @@ export function createCacheAssets(options) {
         };
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
+    // We need to traverse the cache to find every .meta file
+    const metaFiles = [];
+    // Copy fetch-cache to cache folder
+    const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
+    if (fs.existsSync(fetchCachePath)) {
+        const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
+        fs.mkdirSync(fetchOutputPath, { recursive: true });
+        fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
+        buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
+            const fileContent = fs.readFileSync(absolutePath, "utf8");
+            const fileData = JSON.parse(fileContent);
+            fileData?.tags?.forEach((tag) => {
+                metaFiles.push({
+                    tag: { S: path.posix.join(buildId, tag) },
+                    path: {
+                        S: path.posix.join(buildId, relativePath),
+                    },
+                    revalidatedAt: { N: "1" },
+                });
+            });
+        });
+    }
     if (!options.config.dangerous?.disableTagCache) {
-        // Generate dynamodb data
-        // We need to traverse the cache to find every .meta file
-        const metaFiles = [];
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
         buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
@@ -134,26 +153,6 @@ export function createCacheAssets(options) {
                 });
             }
         });
-        // Copy fetch-cache to cache folder
-        const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
-        if (fs.existsSync(fetchCachePath)) {
-            const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
-            fs.mkdirSync(fetchOutputPath, { recursive: true });
-            fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
-            buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
-                const fileContent = fs.readFileSync(absolutePath, "utf8");
-                const fileData = JSON.parse(fileContent);
-                fileData?.tags?.forEach((tag) => {
-                    metaFiles.push({
-                        tag: { S: path.posix.join(buildId, tag) },
-                        path: {
-                            S: path.posix.join(buildId, relativePath),
-                        },
-                        revalidatedAt: { N: "1" },
-                    });
-                });
-            });
-        }
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");

package/dist/build/edge/createEdgeBundle.d.ts

@@ -2,14 +2,15 @@ import type { MiddlewareInfo } from "../../types/next-types";
 import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
 import type { OriginResolver } from "../../types/overrides.js";
 import { type BuildOptions } from "../helper.js";
+type Override = OverrideOptions & {
+    originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
+};
 interface BuildEdgeBundleOptions {
     middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
-    overrides?: OverrideOptions & {
-        originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
-    };
+    overrides?: Override;
     defaultConverter?: IncludedConverter;
     additionalInject?: string;
     includeCache?: boolean;

package/dist/build/edge/createEdgeBundle.js

@@ -10,6 +10,11 @@ import { isEdgeRuntime } from "../helper.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
 export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
     const isInCloudfare = await isEdgeRuntime(overrides);
+    function override(target) {
+        return typeof overrides?.[target] === "string"
+            ? overrides[target]
+            : undefined;
+    }
     await esbuildAsync({
         entryPoints: [entrypoint],
         bundle: true,
@@ -20,31 +25,17 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
         plugins: [
             openNextResolvePlugin({
                 overrides: {
-                    wrapper: typeof overrides?.wrapper === "string"
-                        ? overrides.wrapper
-                        : "aws-lambda",
-                    converter: typeof overrides?.converter === "string"
-                        ? overrides.converter
-                        : defaultConverter,
+                    wrapper: override("wrapper") ?? "aws-lambda",
+                    converter: override("converter") ?? defaultConverter,
                     ...(includeCache
                         ? {
-                            tagCache: typeof overrides?.tagCache === "string"
-                                ? overrides.tagCache
-                                : "dynamodb-lite",
-                            incrementalCache: typeof overrides?.incrementalCache === "string"
-                                ? overrides.incrementalCache
-                                : "s3-lite",
-                            queue: typeof overrides?.queue === "string"
-                                ? overrides.queue
-                                : "sqs-lite",
+                            tagCache: override("tagCache") ?? "dynamodb-lite",
+                            incrementalCache: override("incrementalCache") ?? "s3-lite",
+                            queue: override("queue") ?? "sqs-lite",
                         }
                         : {}),
-                    originResolver: typeof overrides?.originResolver === "string"
-                        ? overrides.originResolver
-                        : "pattern-env",
-                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
-                        ? overrides.proxyExternalRequest
-                        : "node",
+                    originResolver: override("originResolver") ?? "pattern-env",
+                    proxyExternalRequest: override("proxyExternalRequest") ?? "node",
                 },
                 fnName: name,
             }),

package/dist/core/requestHandler.js

@@ -4,23 +4,32 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { convertRes, createServerResponse } from "./routing/util";
-import routingHandler, { MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
 patchAsyncStorage();
 export async function openNextHandler(internalEvent, responseStreaming) {
+    const initialHeaders = internalEvent.headers;
     // 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"];
+    return runWithOpenNextRequestContext({ isISRRevalidation: initialHeaders["x-isr"] === "1" }, async () => {
+        if (initialHeaders["x-forwarded-host"]) {
+            initialHeaders.host = initialHeaders["x-forwarded-host"];
         }
         debug("internalEvent", internalEvent);
+        // These 2 will get overwritten by the routing handler if not using an external middleware
+        const internalHeaders = {
+            initialPath: initialHeaders[INTERNAL_HEADER_INITIAL_PATH] ?? internalEvent.rawPath,
+            resolvedRoutes: initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES]
+                ? JSON.parse(initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES])
+                : [],
+        };
         let routingResult = {
             internalEvent,
             isExternalRewrite: false,
             origin: false,
             isISR: false,
+            ...internalHeaders,
         };
         //#override withRouting
         try {
@@ -65,6 +74,8 @@ export async function openNextHandler(internalEvent, responseStreaming) {
                     isExternalRewrite: false,
                     isISR: false,
                     origin: false,
+                    initialPath: internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }

package/dist/core/routing/routeMatcher.d.ts

@@ -0,0 +1,10 @@
+import type { RouteType } from "../../types/open-next";
+export declare const apiPrefix: string;
+export declare const staticRouteMatcher: (path: string) => {
+    route: string;
+    type: RouteType;
+}[];
+export declare const dynamicRouteMatcher: (path: string) => {
+    route: string;
+    type: RouteType;
+}[];

package/dist/core/routing/routeMatcher.js

@@ -0,0 +1,45 @@
+import { AppPathRoutesManifest, RoutesManifest } from "../../adapters/config/index";
+// Add the locale prefix to the regex so we correctly match the rawPath
+const optionalLocalePrefixRegex = `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`;
+// Add the basepath prefix to the regex so we correctly match the rawPath
+const optionalBasepathPrefixRegex = RoutesManifest.basePath
+    ? `^${RoutesManifest.basePath}/?`
+    : "^/";
+// Add the basePath prefix to the api routes
+export const apiPrefix = `${RoutesManifest.basePath ?? ""}/api`;
+const optionalPrefix = optionalLocalePrefixRegex.replace("^/", optionalBasepathPrefixRegex);
+function routeMatcher(routeDefinitions) {
+    const regexp = routeDefinitions.map((route) => ({
+        page: route.page,
+        regexp: new RegExp(route.regex.replace("^/", optionalPrefix)),
+    }));
+    const appPathsSet = new Set();
+    const routePathsSet = new Set();
+    // We need to use AppPathRoutesManifest here
+    for (const [k, v] of Object.entries(AppPathRoutesManifest)) {
+        if (k.endsWith("page")) {
+            appPathsSet.add(v);
+        }
+        else if (k.endsWith("route")) {
+            routePathsSet.add(v);
+        }
+    }
+    return function matchRoute(path) {
+        const foundRoutes = regexp.filter((route) => route.regexp.test(path));
+        return foundRoutes.map((foundRoute) => {
+            let routeType = "page";
+            if (appPathsSet.has(foundRoute.page)) {
+                routeType = "app";
+            }
+            else if (routePathsSet.has(foundRoute.page)) {
+                routeType = "route";
+            }
+            return {
+                route: foundRoute.page,
+                type: routeType,
+            };
+        });
+    };
+}
+export const staticRouteMatcher = routeMatcher(RoutesManifest.routes.static);
+export const dynamicRouteMatcher = routeMatcher(RoutesManifest.routes.dynamic);

package/dist/core/routing/util.d.ts

@@ -60,7 +60,7 @@ export declare function convertBodyToReadableStream(method: string, body?: strin
  *
  * @__PURE__
  */
-export declare function fixCacheHeaderForHtmlPages(rawPath: string, headers: OutgoingHttpHeaders): void;
+export declare function fixCacheHeaderForHtmlPages(internalEvent: InternalEvent, headers: OutgoingHttpHeaders): void;
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -5,6 +5,7 @@ import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import { parseHeaders } from "../../http/util.js";
 import { debug, error } from "../../adapters/logger.js";
 import { isBinaryContentType } from "../../utils/binary.js";
+import { localizePath } from "./i18n/index.js";
 /**
  *
  * @__PURE__
@@ -169,9 +170,9 @@ var CommonHeaders;
  *
  * @__PURE__
  */
-export function fixCacheHeaderForHtmlPages(rawPath, headers) {
+export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // We don't want to cache error pages
-    if (rawPath === "/404" || rawPath === "/500") {
+    if (internalEvent.rawPath === "/404" || internalEvent.rawPath === "/500") {
         if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
             return;
         }
@@ -179,9 +180,10 @@ export function fixCacheHeaderForHtmlPages(rawPath, headers) {
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
     }
+    const localizedPath = localizePath(internalEvent);
     // WORKAROUND: `NextServer` does not set cache headers for HTML pages
     // https://opennext.js.org/aws/v2/advanced/workaround#workaround-nextserver-does-not-set-cache-headers-for-html-pages
-    if (HtmlPages.includes(rawPath)) {
+    if (HtmlPages.includes(localizedPath)) {
         headers[CommonHeaders.CACHE_CONTROL] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }
@@ -352,7 +354,7 @@ export function fixISRHeaders(headers) {
  */
 export function createServerResponse(internalEvent, headers, responseStream) {
     return new OpenNextNodeResponse((_headers) => {
-        fixCacheHeaderForHtmlPages(internalEvent.rawPath, _headers);
+        fixCacheHeaderForHtmlPages(internalEvent, _headers);
         fixSWRCacheHeader(_headers);
         addOpenNextHeader(_headers);
         fixISRHeaders(_headers);

package/dist/core/routingHandler.d.ts

@@ -1,4 +1,7 @@
 import type { InternalEvent, InternalResult, RoutingResult } from "../types/open-next";
 export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
+export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export declare const INTERNAL_HEADER_INITIAL_PATH = "x-opennext-initial-path";
+export declare const INTERNAL_HEADER_RESOLVED_ROUTES = "x-opennext-resolved-routes";
 export default function routingHandler(event: InternalEvent): Promise<InternalResult | RoutingResult>;

package/dist/core/routingHandler.js

@@ -3,26 +3,12 @@ import { debug } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
+import { apiPrefix, dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
-// Add the locale prefix to the regex so we correctly match the rawPath
-const optionalLocalePrefixRegex = RoutesManifest.locales.length
-    ? `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`
-    : "^/";
-// Add the basepath prefix to the regex so we correctly match the rawPath
-const optionalBasepathPrefixRegex = RoutesManifest.basePath
-    ? `^${RoutesManifest.basePath}/?`
-    : "^/";
-// Add the basePath prefix to the api routes
-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 const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export const INTERNAL_HEADER_INITIAL_PATH = `${INTERNAL_HEADER_PREFIX}initial-path`;
+export const INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
 // Geolocation headers starting from Nextjs 15
 // See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
 const geoHeaderToNextHeader = {
@@ -50,6 +36,14 @@ export default async function routingHandler(event) {
             event.headers[nextGeoName] = value;
         }
     }
+    // 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);
     if ("statusCode" in internalEvent) {
@@ -75,9 +69,9 @@ export default async function routingHandler(event) {
         internalEvent = beforeRewrites.internalEvent;
         isExternalRewrite = beforeRewrites.isExternalRewrite;
     }
-    const isStaticRoute = !isExternalRewrite &&
-        staticRegexp.some((route) => route.test(internalEvent.rawPath));
-    if (!isStaticRoute && !isExternalRewrite) {
+    const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+    const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
+    if (!(isStaticRoute || isExternalRewrite)) {
         // Second rewrite to be applied
         const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
         internalEvent = afterRewrites.internalEvent;
@@ -86,9 +80,9 @@ export default async function routingHandler(event) {
     // We want to run this just before the dynamic route check
     const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
     internalEvent = fallbackEvent;
-    const isDynamicRoute = !isExternalRewrite &&
-        dynamicRegexp.some((route) => route.test(internalEvent.rawPath));
-    if (!isDynamicRoute && !isStaticRoute && !isExternalRewrite) {
+    const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+    const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
+    if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
         // Fallback rewrite to be applied
         const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
         internalEvent = fallbackRewrites.internalEvent;
@@ -103,12 +97,12 @@ export default async function routingHandler(event) {
     const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
     // 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 &&
+    if (!(isRouteFoundBeforeAllRewrites ||
+        isApiRoute ||
+        isNextImageRoute ||
         // We need to check again once all rewrites have been applied
-        !staticRegexp.some((route) => route.test(internalEvent.rawPath)) &&
-        !dynamicRegexp.some((route) => route.test(internalEvent.rawPath))) {
+        staticRouteMatcher(internalEvent.rawPath).length > 0 ||
+        dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
         internalEvent = {
             ...internalEvent,
             rawPath: "/404",
@@ -136,10 +130,17 @@ export default async function routingHandler(event) {
         ...middlewareResponseHeaders,
         ...nextHeaders,
     });
+    const resolvedRoutes = [
+        ...foundStaticRoute,
+        ...foundDynamicRoute,
+    ];
+    debug("resolvedRoutes", resolvedRoutes);
     return {
         internalEvent,
         isExternalRewrite,
         origin: false,
         isISR,
+        initialPath: event.rawPath,
+        resolvedRoutes,
     };
 }

package/dist/overrides/wrappers/cloudflare-node.js

@@ -1,4 +1,6 @@
 import { Writable } from "node:stream";
+// Response with null body status (101, 204, 205, or 304) cannot have a body.
+const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
     globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
@@ -29,7 +31,8 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
                     controller.enqueue(Uint8Array.from(chunk.chunk ?? chunk));
                 },
             });
-            const response = new Response(readable, {
+            const body = NULL_BODY_STATUSES.has(statusCode) ? null : readable;
+            const response = new Response(body, {
                 status: statusCode,
                 headers: responseHeaders,
             });

package/dist/plugins/edge.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
 /**
  * @param opts.nextDir - The path to the .next directory
@@ -126,6 +126,8 @@ ${contents}
                 const PrerenderManifest = loadPrerenderManifest(nextDir);
                 const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
+                const AppPathsManifest = loadAppPathsManifest(nextDir);
+                const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
                 const contents = `
   import path from "node:path";
 
@@ -146,6 +148,9 @@ ${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)};
+  export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+
 
   process.env.NEXT_BUILD_ID = BuildId;
 `;

package/dist/types/open-next.d.ts

@@ -68,11 +68,18 @@ export interface Origin {
 }
 export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
+export type RouteType = "route" | "page" | "app";
+export interface ResolvedRoute {
+    route: string;
+    type: RouteType;
+}
 export interface RoutingResult {
     internalEvent: InternalEvent;
     isExternalRewrite: boolean;
     origin: Origin | false;
     isISR: boolean;
+    initialPath: string;
+    resolvedRoutes: ResolvedRoute[];
 }
 export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"middleware"> {
 }

package/dist/types/overrides.d.ts

@@ -13,7 +13,7 @@ export interface Queue {
     send(message: QueueMessage): Promise<void>;
     name: string;
 }
-export type S3CachedFile = {
+export type CachedFile = {
     type: "redirect";
     props?: Object;
     meta?: Meta;
@@ -32,12 +32,12 @@ export type S3CachedFile = {
     body: string;
     meta?: Meta;
 };
-export type S3FetchCache = Object;
+export type FetchCache = Object;
 export type WithLastModified<T> = {
     lastModified?: number;
     value?: T;
 };
-export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? S3FetchCache : S3CachedFile) & {
+export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? FetchCache : CachedFile) & {
     revalidate?: number | false;
 };
 export type IncrementalCache = {

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "bin": {
     "open-next": "./dist/index.js"
   },