@opennextjs/aws 3.4.2 → 3.5.1

package/dist/core/routing/i18n/index.js

@@ -1,5 +1,7 @@
 import { NextConfig } from "../../../adapters/config/index.js";
+import { emptyReadableStream } from "../../../utils/stream.js";
 import { debug } from "../../../adapters/logger.js";
+import { constructNextUrl } from "../util.js";
 import { acceptLanguage } from "./accept-header";
 function isLocalizedPath(path) {
     return (NextConfig.i18n?.locales.includes(path.split("/")[1].toLowerCase()) ?? false);
@@ -12,9 +14,40 @@ function getLocaleFromCookie(cookies) {
         ? i18n?.locales.find((locale) => nextLocale === locale.toLowerCase())
         : undefined;
 }
-function detectLocale(internalEvent, i18n) {
+// Inspired by https://github.com/vercel/next.js/blob/6d93d652e0e7ba72d9a3b66e78746dce2069db03/packages/next/src/shared/lib/i18n/detect-domain-locale.ts#L3-L25
+/**
+ * @param arg an object containing the hostname and detectedLocale
+ * @returns The `DomainLocale` object if a domain is detected, `undefined` otherwise
+ */
+export function detectDomainLocale({ hostname, detectedLocale, }) {
+    const i18n = NextConfig.i18n;
+    const domains = i18n?.domains;
+    if (!domains) {
+        return;
+    }
+    const lowercasedLocale = detectedLocale?.toLowerCase();
+    for (const domain of domains) {
+        // We remove the port if present
+        const domainHostname = domain.domain.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname ||
+            lowercasedLocale === domain.defaultLocale.toLowerCase() ||
+            domain.locales?.some((locale) => lowercasedLocale === locale.toLowerCase())) {
+            return domain;
+        }
+    }
+}
+/**
+ *
+ * @param internalEvent
+ * @param i18n
+ * @returns The detected locale, if `localeDetection` is set to `false` it will return the default locale **or** the domain default locale if a domain is detected.
+ */
+export function detectLocale(internalEvent, i18n) {
+    const domainLocale = detectDomainLocale({
+        hostname: internalEvent.headers.host,
+    });
     if (i18n.localeDetection === false) {
-        return i18n.defaultLocale;
+        return domainLocale?.defaultLocale ?? i18n.defaultLocale;
     }
     const cookiesLocale = getLocaleFromCookie(internalEvent.cookies);
     const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
@@ -22,18 +55,79 @@ function detectLocale(internalEvent, i18n) {
         cookiesLocale,
         preferredLocale,
         defaultLocale: i18n.defaultLocale,
+        domainLocale,
     });
-    return cookiesLocale ?? preferredLocale ?? i18n.defaultLocale;
-    // TODO: handle domain based locale detection
+    return (domainLocale?.defaultLocale ??
+        cookiesLocale ??
+        preferredLocale ??
+        i18n.defaultLocale);
 }
+/**
+ * This function is used for OpenNext internal routing to localize the path for next config rewrite/redirects/headers and the middleware
+ * @param internalEvent
+ * @returns The localized path
+ */
 export function localizePath(internalEvent) {
     const i18n = NextConfig.i18n;
     if (!i18n) {
         return internalEvent.rawPath;
     }
+    // When the path is already localized we don't need to do anything
     if (isLocalizedPath(internalEvent.rawPath)) {
         return internalEvent.rawPath;
     }
     const detectedLocale = detectLocale(internalEvent, i18n);
     return `/${detectedLocale}${internalEvent.rawPath}`;
 }
+/**
+ *
+ * @param internalEvent
+ * In this function, for domain locale redirect we need to rely on the host to be present and correct
+ * @returns `false` if no redirect is needed, `InternalResult` if a redirect is needed
+ */
+export function handleLocaleRedirect(internalEvent) {
+    const i18n = NextConfig.i18n;
+    if (!i18n ||
+        i18n.localeDetection === false ||
+        internalEvent.rawPath !== "/") {
+        return false;
+    }
+    const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
+    const detectedLocale = detectLocale(internalEvent, i18n);
+    const domainLocale = detectDomainLocale({
+        hostname: internalEvent.headers.host,
+    });
+    const preferredDomain = detectDomainLocale({
+        detectedLocale: preferredLocale,
+    });
+    if (domainLocale && preferredDomain) {
+        const isPDomain = preferredDomain.domain === domainLocale.domain;
+        const isPLocale = preferredDomain.defaultLocale === preferredLocale;
+        if (!isPDomain || !isPLocale) {
+            const scheme = `http${preferredDomain.http ? "" : "s"}`;
+            const rlocale = isPLocale ? "" : preferredLocale;
+            return {
+                type: "core",
+                statusCode: 307,
+                headers: {
+                    Location: `${scheme}://${preferredDomain.domain}/${rlocale}`,
+                },
+                body: emptyReadableStream(),
+                isBase64Encoded: false,
+            };
+        }
+    }
+    const defaultLocale = domainLocale?.defaultLocale ?? i18n.defaultLocale;
+    if (detectedLocale.toLowerCase() !== defaultLocale.toLowerCase()) {
+        return {
+            type: "core",
+            statusCode: 307,
+            headers: {
+                Location: constructNextUrl(internalEvent.url, `/${detectedLocale}`),
+            },
+            body: emptyReadableStream(),
+            isBase64Encoded: false,
+        };
+    }
+    return false;
+}

package/dist/core/routing/matcher.js

@@ -2,8 +2,8 @@ import { NextConfig } from "../../adapters/config/index";
 import { compile, match } from "path-to-regexp";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
-import { localizePath } from "./i18n";
-import { convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
+import { handleLocaleRedirect, localizePath } from "./i18n";
+import { constructNextUrl, convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
 const routeHasMatcher = (headers, cookies, query) => (redirect) => {
     switch (redirect.type) {
         case "header":
@@ -96,7 +96,7 @@ export function getNextConfigHeaders(event, configHeaders) {
     return requestHeaders;
 }
 export function handleRewrites(event, rewrites) {
-    const { rawPath, headers, query, cookies } = event;
+    const { rawPath, headers, query, cookies, url } = event;
     const localizedRawPath = localizePath(event);
     const matcher = routeHasMatcher(headers, cookies, query);
     const computeHas = computeParamHas(headers, cookies, query);
@@ -107,7 +107,7 @@ export function handleRewrites(event, rewrites) {
             checkHas(matcher, route.missing, true));
     });
     let finalQuery = query;
-    let rewrittenUrl = rawPath;
+    let rewrittenUrl = url;
     const isExternalRewrite = isExternal(rewrite?.destination);
     debug("isExternalRewrite", isExternalRewrite);
     if (rewrite) {
@@ -121,12 +121,12 @@ export function handleRewrites(event, rewrites) {
         // %2B does not get interpreted as a space in the URL thus breaking the query string.
         const encodePlusQueryString = queryString.replaceAll("+", "%20");
         debug("urlParts", { pathname, protocol, hostname, queryString });
-        const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
-        const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
-        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
+        const toDestinationPath = compile(escapeRegex(pathname));
+        const toDestinationHost = compile(escapeRegex(hostname));
+        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString));
         const params = {
             // params for the source
-            ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
+            ...getParamsFromSource(match(escapeRegex(rewrite.source)))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
                 return Object.assign(acc, computeHas(cur));
@@ -147,19 +147,20 @@ export function handleRewrites(event, rewrites) {
         }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
-            : `${rewrittenPath}`;
+            : new URL(rewrittenPath, event.url).href;
         // Should we merge the query params or use only the ones from the rewrite?
         finalQuery = {
             ...query,
             ...convertFromQueryString(rewrittenQuery),
         };
+        rewrittenUrl += convertToQueryString(finalQuery);
         debug("rewrittenUrl", { rewrittenUrl, finalQuery, isUsingParams });
     }
     return {
         internalEvent: {
             ...event,
-            rawPath: rewrittenUrl,
-            url: `${rewrittenUrl}${convertToQueryString(finalQuery)}`,
+            rawPath: new URL(rewrittenUrl).pathname,
+            url: rewrittenUrl,
         },
         __rewrite: rewrite,
         isExternalRewrite,
@@ -214,6 +215,9 @@ export function handleRedirects(event, redirects) {
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
     if (trailingSlashRedirect)
         return trailingSlashRedirect;
+    const localeRedirect = handleLocaleRedirect(event);
+    if (localeRedirect)
+        return localeRedirect;
     const { internalEvent, __rewrite } = handleRewrites(event, redirects.filter((r) => !r.internal));
     if (__rewrite && !__rewrite.internal) {
         return {
@@ -251,7 +255,7 @@ export function fixDataPage(internalEvent, buildId) {
             ...internalEvent,
             rawPath: newPath,
             query,
-            url: `${newPath}${convertToQueryString(query)}`,
+            url: new URL(`${newPath}${convertToQueryString(query)}`, internalEvent.url).href,
         };
     }
     return internalEvent;
@@ -278,7 +282,7 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
             event: {
                 ...internalEvent,
                 rawPath: "/404",
-                url: "/404",
+                url: constructNextUrl(internalEvent.url, "/404"),
                 headers: {
                     ...internalEvent.headers,
                     "x-invoke-status": "404",

package/dist/core/routing/middleware.js

@@ -1,4 +1,4 @@
-import { MiddlewareManifest, NextConfig } from "../../adapters/config/index.js";
+import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { localizePath } from "./i18n/index.js";
 //NOTE: we should try to avoid importing stuff from next as much as possible
@@ -10,7 +10,8 @@ import { localizePath } from "./i18n/index.js";
 // } = require("next/dist/server/web/spec-extension/adapters/next-request");
 import { convertBodyToReadableStream, convertToQueryString, getMiddlewareMatch, isExternal, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
-const middleMatch = getMiddlewareMatch(middlewareManifest);
+const functionsConfigManifest = FunctionsConfigManifest;
+const middleMatch = getMiddlewareMatch(middlewareManifest, functionsConfigManifest);
 function defaultMiddlewareLoader() {
     // @ts-expect-error - This is bundled
     return import("./middleware.mjs");
@@ -30,16 +31,9 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
     if (!hasMatch)
         return internalEvent;
-    // Retrieve the protocol:
-    // - In lambda, the url only contains the rawPath and the query - default to https
-    // - In cloudflare, the protocol is usually http in dev and https in production
-    const protocol = internalEvent.url.startsWith("http://") ? "http:" : "https:";
-    const host = headers.host
-        ? `${protocol}//${headers.host}`
-        : "http://localhost:3000";
-    const initialUrl = new URL(normalizedPath, host);
+    const initialUrl = new URL(normalizedPath, internalEvent.url);
     initialUrl.search = convertToQueryString(internalEvent.query);
-    const url = initialUrl.toString();
+    const url = initialUrl.href;
     const middleware = await middlewareLoader();
     const result = await middleware.default({
         // `geo` is pre Next 15.
@@ -100,9 +94,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // the redirected url and end the response.
     if (statusCode >= 300 && statusCode < 400) {
         resHeaders.location =
-            responseHeaders
-                .get("location")
-                ?.replace("http://localhost:3000", `${protocol}//${internalEvent.headers.host}`) ?? resHeaders.location;
+            responseHeaders.get("location") ?? resHeaders.location;
         // res.setHeader("Location", location);
         return {
             body: emptyReadableStream(),
@@ -120,28 +112,23 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     let middlewareQueryString = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
+        newUrl = rewriteUrl;
+        rewritten = true;
         // If not a string, it should probably throw
-        if (isExternal(rewriteUrl, internalEvent.headers.host)) {
-            newUrl = rewriteUrl;
-            rewritten = true;
+        if (isExternal(newUrl, internalEvent.headers.host)) {
             isExternalRewrite = true;
         }
         else {
             const rewriteUrlObject = new URL(rewriteUrl);
-            newUrl = rewriteUrlObject.pathname;
             // Reset the query params if the middleware is a rewrite
-            if (middlewareQueryString.__nextDataReq) {
-                middlewareQueryString = {
+            middlewareQueryString = middlewareQueryString.__nextDataReq
+                ? {
                     __nextDataReq: middlewareQueryString.__nextDataReq,
-                };
-            }
-            else {
-                middlewareQueryString = {};
-            }
+                }
+                : {};
             rewriteUrlObject.searchParams.forEach((v, k) => {
                 middlewareQueryString[k] = v;
             });
-            rewritten = true;
         }
     }
     // If the middleware returned a `NextResponse`, pipe the body to res. This will return
@@ -160,9 +147,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     return {
         responseHeaders: resHeaders,
         url: newUrl,
-        rawPath: rewritten
-            ? (newUrl ?? internalEvent.rawPath)
-            : internalEvent.rawPath,
+        rawPath: new URL(newUrl).pathname,
         type: internalEvent.type,
         headers: { ...internalEvent.headers, ...reqHeaders },
         body: internalEvent.body,

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

@@ -0,0 +1 @@
+export declare function generateMessageGroupId(rawPath: string): string;

package/dist/core/routing/queue.js

@@ -0,0 +1,41 @@
+// Since we're using a FIFO queue, every messageGroupId is treated sequentially
+// This could cause a backlog of messages in the queue if there is too much page to
+// revalidate at once. To avoid this, we generate a random messageGroupId for each
+// revalidation request.
+// We can't just use a random string because we need to ensure that the same rawPath
+// will always have the same messageGroupId.
+// https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript#answer-47593316
+export function generateMessageGroupId(rawPath) {
+    let a = cyrb128(rawPath);
+    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    let t = (a += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    // This will generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    // This means that we could have 1000 revalidate request at the same time
+    const maxConcurrency = Number.parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
+    const randomInt = Math.floor(randomFloat * maxConcurrency);
+    return `revalidate-${randomInt}`;
+}
+// Used to generate a hash int from a string
+function cyrb128(str) {
+    let h1 = 1779033703;
+    let h2 = 3144134277;
+    let h3 = 1013904242;
+    let h4 = 2773480762;
+    for (let i = 0, k; i < str.length; i++) {
+        k = str.charCodeAt(i);
+        h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+        h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+        h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+        h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+    }
+    h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
+    h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
+    h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
+    h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
+    // biome-ignore lint/style/noCommaOperator:
+    (h1 ^= h2 ^ h3 ^ h4), (h2 ^= h1), (h3 ^= h1), (h4 ^= h1);
+    return h1 >>> 0;
+}

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

@@ -1,7 +1,7 @@
 import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
-import type { MiddlewareManifest } from "../../types/next-types";
+import type { FunctionsConfigManifest, MiddlewareManifest } from "../../types/next-types";
 import type { InternalEvent, InternalResult, RoutingResult, StreamCreator } from "../../types/open-next.js";
 /**
  *
@@ -19,6 +19,16 @@ export declare function getUrlParts(url: string, isExternal: boolean): {
     protocol: string;
     queryString: string;
 };
+/**
+ * Creates an URL to a Next page
+ *
+ * @param baseUrl Used to get the origin
+ * @param path The pathname
+ * @returns The Next URL considering the basePath
+ *
+ * @__PURE__
+ */
+export declare function constructNextUrl(baseUrl: string, path: string): string;
 /**
  *
  * @__PURE__
@@ -41,7 +51,7 @@ export declare function convertToQuery(querystring: string): Record<string, stri
  *
  * @__PURE__
  */
-export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifest): RegExp[];
+export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifest, functionsManifest?: FunctionsConfigManifest): RegExp[];
 /**
  *
  * @__PURE__
@@ -76,7 +86,6 @@ export declare function addOpenNextHeader(headers: OutgoingHttpHeaders): void;
  * @__PURE__
  */
 export declare function revalidateIfRequired(host: string, rawPath: string, headers: OutgoingHttpHeaders, req?: IncomingMessage): Promise<void>;
-export declare function generateMessageGroupId(rawPath: string): string;
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -6,6 +6,7 @@ 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";
+import { generateMessageGroupId } from "./queue.js";
 /**
  *
  * @__PURE__
@@ -56,6 +57,21 @@ export function getUrlParts(url, isExternal) {
         queryString: match[4]?.slice(1) ?? "",
     };
 }
+/**
+ * Creates an URL to a Next page
+ *
+ * @param baseUrl Used to get the origin
+ * @param path The pathname
+ * @returns The Next URL considering the basePath
+ *
+ * @__PURE__
+ */
+export function constructNextUrl(baseUrl, path) {
+    // basePath is generated as "" if not provided on Next.js 15 (not sure about older versions)
+    const nextBasePath = NextConfig.basePath ?? "";
+    const url = new URL(`${nextBasePath}${path}`, baseUrl);
+    return url.href;
+}
 /**
  *
  * @__PURE__
@@ -119,7 +135,10 @@ export function convertToQuery(querystring) {
  *
  * @__PURE__
  */
-export function getMiddlewareMatch(middlewareManifest) {
+export function getMiddlewareMatch(middlewareManifest, functionsManifest) {
+    if (functionsManifest?.functions?.["/_middleware"]) {
+        return (functionsManifest.functions["/_middleware"].matchers?.map(({ regexp }) => new RegExp(regexp)) ?? [/.*/]);
+    }
     const rootMiddleware = middlewareManifest.middleware["/"];
     if (!rootMiddleware?.matchers)
         return [];
@@ -246,10 +265,7 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
         // If data has the same etag during these 5 min dedup window, it will be deduplicated and not revalidated.
         try {
             const hash = (str) => crypto.createHash("md5").update(str).digest("hex");
-            const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
-            const lastModified = globalThis.lastModified[requestId] > 0
-                ? globalThis.lastModified[requestId]
-                : "";
+            const lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
             // For some weird cases, lastModified is not set, haven't been able to figure out yet why
             // For those cases we add the etag to the deduplication id, it might help
             const etag = headers.etag ?? headers.ETag ?? "";
@@ -264,47 +280,6 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
         }
     }
 }
-// Since we're using a FIFO queue, every messageGroupId is treated sequentially
-// This could cause a backlog of messages in the queue if there is too much page to
-// revalidate at once. To avoid this, we generate a random messageGroupId for each
-// revalidation request.
-// We can't just use a random string because we need to ensure that the same rawPath
-// will always have the same messageGroupId.
-// https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript#answer-47593316
-export function generateMessageGroupId(rawPath) {
-    let a = cyrb128(rawPath);
-    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
-    let t = (a += 0x6d2b79f5);
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    // This will generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
-    // This means that we could have 1000 revalidate request at the same time
-    const maxConcurrency = Number.parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
-    const randomInt = Math.floor(randomFloat * maxConcurrency);
-    return `revalidate-${randomInt}`;
-}
-// Used to generate a hash int from a string
-function cyrb128(str) {
-    let h1 = 1779033703;
-    let h2 = 3144134277;
-    let h3 = 1013904242;
-    let h4 = 2773480762;
-    for (let i = 0, k; i < str.length; i++) {
-        k = str.charCodeAt(i);
-        h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
-        h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
-        h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
-        h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
-    }
-    h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
-    h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
-    h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
-    h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
-    // biome-ignore lint/style/noCommaOperator:
-    (h1 ^= h2 ^ h3 ^ h4), (h2 ^= h1), (h3 ^= h1), (h4 ^= h1);
-    return h1 >>> 0;
-}
 /**
  *
  * @__PURE__
@@ -315,15 +290,14 @@ export function fixISRHeaders(headers) {
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
     }
-    const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
-    const _lastModified = globalThis.lastModified[requestId] ?? 0;
+    const _lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
     if (headers[CommonHeaders.NEXT_CACHE] === "HIT" && _lastModified > 0) {
         // calculate age
         const age = Math.round((Date.now() - _lastModified) / 1000);
         // extract s-maxage from cache-control
         const regex = /s-maxage=(\d+)/;
         const cacheControl = headers[CommonHeaders.CACHE_CONTROL];
-        debug("cache-control", cacheControl, globalThis.lastModified, Date.now());
+        debug("cache-control", cacheControl, _lastModified, Date.now());
         if (typeof cacheControl !== "string")
             return;
         const match = cacheControl.match(regex);
@@ -366,7 +340,8 @@ export function createServerResponse(routingResult, headers, responseStream) {
 }
 // This function is used only for `res.revalidate()`
 export async function invalidateCDNOnRequest(params, headers) {
-    const { internalEvent, initialPath, resolvedRoutes } = params;
+    const { internalEvent, resolvedRoutes, initialURL } = params;
+    const initialPath = new URL(initialURL).pathname;
     const isIsrRevalidation = internalEvent.headers["x-isr"] === "1";
     if (!isIsrRevalidation &&
         headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {

package/dist/core/routingHandler.d.ts

@@ -2,6 +2,7 @@ import type { InternalEvent, InternalResult, RoutingResult } from "../types/open
 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_INITIAL_URL = "x-opennext-initial-url";
+export declare const INTERNAL_HEADER_LOCALE = "x-opennext-locale";
 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

@@ -1,13 +1,16 @@
-import { BuildId, ConfigHeaders, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
+import { BuildId, ConfigHeaders, NextConfig, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
 import { debug } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
+import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
 import { apiPrefix, dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
+import { constructNextUrl } from "./routing/util";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
 export const INTERNAL_HEADER_PREFIX = "x-opennext-";
-export const INTERNAL_HEADER_INITIAL_PATH = `${INTERNAL_HEADER_PREFIX}initial-path`;
+export const INTERNAL_HEADER_INITIAL_URL = `${INTERNAL_HEADER_PREFIX}initial-url`;
+export const INTERNAL_HEADER_LOCALE = `${INTERNAL_HEADER_PREFIX}locale`;
 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
@@ -106,7 +109,7 @@ export default async function routingHandler(event) {
         internalEvent = {
             ...internalEvent,
             rawPath: "/404",
-            url: "/404",
+            url: constructNextUrl(internalEvent.url, "/404"),
             headers: {
                 ...internalEvent.headers,
                 "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
@@ -140,7 +143,10 @@ export default async function routingHandler(event) {
         isExternalRewrite,
         origin: false,
         isISR,
-        initialPath: event.rawPath,
         resolvedRoutes,
+        initialURL: event.url,
+        locale: NextConfig.i18n
+            ? detectLocale(internalEvent, NextConfig.i18n)
+            : undefined,
     };
 }

package/dist/core/util.d.ts

@@ -1,5 +1,2 @@
-import type { MiddlewareManifest } from "../types/next-types.js";
-export declare const requestHandler: any;
-export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifest): RegExp[];
-export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;
+export declare const requestHandler: (metadata: Record<string, any>) => any;
 export declare function setNextjsPrebundledReact(rawPath: string): void;

package/dist/core/util.js

@@ -1,5 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
 import { AppPathsManifestKeys, NextConfig, RoutesManifest, } from "../adapters/config/index.js";
 // @ts-ignore
 import NextServer from "next/dist/server/next-server.js";
@@ -18,7 +16,7 @@ applyNextjsRequireHooksOverride();
 //#endOverride
 const cacheHandlerPath = require.resolve("./cache.cjs");
 // @ts-ignore
-export const requestHandler = new NextServer.default({
+const nextServer = new NextServer.default({
     //#override requestHandlerHost
     hostname: "localhost",
     port: 3000,
@@ -49,18 +47,12 @@ export const requestHandler = new NextServer.default({
     customServer: false,
     dev: false,
     dir: __dirname,
-}).getRequestHandler();
-export function getMiddlewareMatch(middlewareManifest) {
-    const rootMiddleware = middlewareManifest.middleware["/"];
-    if (!rootMiddleware?.matchers)
-        return [];
-    return rootMiddleware.matchers.map(({ regexp }) => new RegExp(regexp));
-}
-export function loadMiddlewareManifest(nextDir) {
-    const filePath = path.join(nextDir, "server", "middleware-manifest.json");
-    const json = fs.readFileSync(filePath, "utf-8");
-    return JSON.parse(json);
-}
+});
+// `getRequestHandlerWithMetadata` is not available in older versions of Next.js
+// It is required to for next 15.2 to pass metadata for page router data route
+export const requestHandler = (metadata) => "getRequestHandlerWithMetadata" in nextServer
+    ? nextServer.getRequestHandlerWithMetadata(metadata)
+    : nextServer.getRequestHandler();
 //#override setNextjsPrebundledReact
 export function setNextjsPrebundledReact(rawPath) {
     // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React

package/dist/overrides/converters/aws-apigw-v1.js

@@ -1,6 +1,6 @@
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
-import { removeUndefinedFromQuery } from "./utils";
+import { extractHostFromHeaders, removeUndefinedFromQuery } from "./utils";
 function normalizeAPIGatewayProxyEventHeaders(event) {
     event.multiValueHeaders;
     const headers = {};
@@ -41,13 +41,14 @@ function normalizeAPIGatewayProxyEventQueryParams(event) {
 }
 async function convertFromAPIGatewayProxyEvent(event) {
     const { path, body, httpMethod, requestContext, isBase64Encoded } = event;
+    const headers = normalizeAPIGatewayProxyEventHeaders(event);
     return {
         type: "core",
         method: httpMethod,
         rawPath: path,
-        url: path + normalizeAPIGatewayProxyEventQueryParams(event),
+        url: `https://${extractHostFromHeaders(headers)}${path}${normalizeAPIGatewayProxyEventQueryParams(event)}`,
         body: Buffer.from(body ?? "", isBase64Encoded ? "base64" : "utf8"),
-        headers: normalizeAPIGatewayProxyEventHeaders(event),
+        headers,
         remoteAddress: requestContext.identity.sourceIp,
         query: removeUndefinedFromQuery(event.multiValueQueryStringParameters ?? {}),
         cookies: event.multiValueHeaders?.cookie?.reduce((acc, cur) => {