@opennextjs/aws 3.4.2 → 3.5.0

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,20 @@ 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) {
+    const nextBasePath = NextConfig.basePath;
+    const url = new URL(`${nextBasePath}${path}`, baseUrl);
+    return url.href;
+}
 /**
  *
  * @__PURE__
@@ -119,7 +134,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 +264,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 +279,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 +289,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 +339,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) => {

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

@@ -2,7 +2,7 @@ import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery } from "../../core/routing/util";
-import { removeUndefinedFromQuery } from "./utils";
+import { extractHostFromHeaders, removeUndefinedFromQuery } from "./utils";
 // Not sure which one is really needed as this is not documented anywhere but server actions redirect are not working without this,
 // it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
 const CloudFrontBlacklistedHeaders = [
@@ -54,13 +54,14 @@ function normalizeAPIGatewayProxyEventV2Headers(event) {
 }
 async function convertFromAPIGatewayProxyEventV2(event) {
     const { rawPath, rawQueryString, requestContext } = event;
+    const headers = normalizeAPIGatewayProxyEventV2Headers(event);
     return {
         type: "core",
         method: requestContext.http.method,
         rawPath,
-        url: rawPath + (rawQueryString ? `?${rawQueryString}` : ""),
+        url: `https://${extractHostFromHeaders(headers)}${rawPath}${rawQueryString ? `?${rawQueryString}` : ""}`,
         body: normalizeAPIGatewayProxyEventV2Body(event),
-        headers: normalizeAPIGatewayProxyEventV2Headers(event),
+        headers,
         remoteAddress: requestContext.http.sourceIp,
         query: removeUndefinedFromQuery(convertToQuery(rawQueryString)),
         cookies: event.cookies?.reduce((acc, cur) => {

package/dist/overrides/converters/aws-cloudfront.js

@@ -2,6 +2,7 @@ import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery, convertToQueryString } from "../../core/routing/util";
+import { extractHostFromHeaders } from "./utils";
 const cloudfrontBlacklistedHeaders = [
     // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
     "connection",
@@ -56,17 +57,18 @@ function normalizeCloudFrontRequestEventHeaders(rawHeaders) {
     return headers;
 }
 async function convertFromCloudFrontRequestEvent(event) {
-    const { method, uri, querystring, body, headers, clientIp } = event.Records[0].cf.request;
+    const { method, uri, querystring, body, headers: cfHeaders, clientIp, } = event.Records[0].cf.request;
+    const headers = normalizeCloudFrontRequestEventHeaders(cfHeaders);
     return {
         type: "core",
         method,
         rawPath: uri,
-        url: uri + (querystring ? `?${querystring}` : ""),
+        url: `https://${extractHostFromHeaders(headers)}${uri}${querystring ? `?${querystring}` : ""}`,
         body: Buffer.from(body?.data ?? "", body?.encoding === "base64" ? "base64" : "utf8"),
-        headers: normalizeCloudFrontRequestEventHeaders(headers),
+        headers,
         remoteAddress: clientIp,
         query: convertToQuery(querystring),
-        cookies: headers.cookie?.reduce((acc, cur) => {
+        cookies: cfHeaders.cookie?.reduce((acc, cur) => {
             const { key = "", value } = cur;
             acc[key] = value;
             return acc;

package/dist/overrides/converters/edge.js

@@ -42,16 +42,7 @@ const converter = {
     },
     convertTo: async (result) => {
         if ("internalEvent" in result) {
-            let url = result.internalEvent.url;
-            if (!result.isExternalRewrite) {
-                if (result.origin) {
-                    url = `${result.origin.protocol}://${result.origin.host}${result.origin.port ? `:${result.origin.port}` : ""}${url}`;
-                }
-                else {
-                    url = `https://${result.internalEvent.headers.host}${url}`;
-                }
-            }
-            const request = new Request(url, {
+            const request = new Request(result.internalEvent.url, {
                 body: result.internalEvent.body,
                 method: result.internalEvent.method,
                 headers: {

package/dist/overrides/converters/node.js

@@ -1,4 +1,5 @@
 import { parseCookies } from "../../http/util";
+import { extractHostFromHeaders } from "./utils";
 const converter = {
     convertFrom: async (req) => {
         const body = await new Promise((resolve) => {
@@ -10,20 +11,21 @@ const converter = {
                 resolve(Buffer.concat(chunks));
             });
         });
-        const url = new URL(req.url, `http://${req.headers.host}`);
+        const headers = Object.fromEntries(Object.entries(req.headers ?? {})
+            .map(([key, value]) => [
+            key.toLowerCase(),
+            Array.isArray(value) ? value.join(",") : value,
+        ])
+            .filter(([key]) => key));
+        const url = new URL(req.url, `http://${extractHostFromHeaders(headers)}`);
         const query = Object.fromEntries(url.searchParams.entries());
         return {
             type: "core",
             method: req.method ?? "GET",
             rawPath: url.pathname,
-            url: url.pathname + url.search,
+            url: url.href,
             body,
-            headers: Object.fromEntries(Object.entries(req.headers ?? {})
-                .map(([key, value]) => [
-                key.toLowerCase(),
-                Array.isArray(value) ? value.join(",") : value,
-            ])
-                .filter(([key]) => key)),
+            headers,
             remoteAddress: req.headers["x-forwarded-for"] ??
                 req.socket.remoteAddress ??
                 "::1",

package/dist/overrides/converters/utils.d.ts

@@ -1 +1,8 @@
 export declare function removeUndefinedFromQuery(query: Record<string, string | string[] | undefined>): Record<string, string | string[]>;
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export declare function extractHostFromHeaders(headers: Record<string, string>): string;

package/dist/overrides/converters/utils.js

@@ -7,3 +7,12 @@ export function removeUndefinedFromQuery(query) {
     }
     return newQuery;
 }
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export function extractHostFromHeaders(headers) {
+    return headers["x-forwarded-host"] ?? headers.host ?? "on";
+}

package/dist/overrides/imageLoader/s3-lite.d.ts

@@ -0,0 +1,3 @@
+import type { ImageLoader } from "../../types/overrides";
+declare const s3Loader: ImageLoader;
+export default s3Loader;

package/dist/overrides/imageLoader/s3-lite.js

@@ -0,0 +1,61 @@
+import { Readable } from "node:stream";
+import { AwsClient } from "aws4fetch";
+import { FatalError } from "../../utils/error";
+let awsClient = null;
+const { BUCKET_NAME, BUCKET_KEY_PREFIX } = process.env;
+// https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+// If AWS_REGION is defined it will override AWS_DEFAULT_REGION
+const BUCKET_REGION = process.env.BUCKET_REGION ??
+    process.env.AWS_REGION ??
+    process.env.AWS_DEFAULT_REGION;
+const getAwsClient = () => {
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: BUCKET_REGION,
+    });
+    return awsClient;
+};
+function ensureEnvExists() {
+    if (!(BUCKET_NAME || BUCKET_KEY_PREFIX || BUCKET_REGION)) {
+        throw new FatalError("Bucket name, region and key prefix must be defined!");
+    }
+}
+const awsFetch = async (key, options) => {
+    const client = getAwsClient();
+    const url = `https://${BUCKET_NAME}.s3.${BUCKET_REGION}.amazonaws.com/${key}`;
+    return client.fetch(url, options);
+};
+const s3Loader = {
+    name: "s3-lite",
+    load: async (key) => {
+        ensureEnvExists();
+        const keyPrefix = BUCKET_KEY_PREFIX?.replace(/^\/|\/$/g, "");
+        const response = await awsFetch(keyPrefix
+            ? `${keyPrefix}/${key.replace(/^\//, "")}`
+            : key.replace(/^\//, ""), {
+            method: "GET",
+        });
+        if (response.status === 404) {
+            throw new FatalError("The specified key does not exist.");
+        }
+        if (response.status !== 200) {
+            throw new FatalError(`Failed to get image. Status code: ${response.status}`);
+        }
+        if (!response.body) {
+            throw new FatalError("No body in aws4fetch s3 response");
+        }
+        // We need to cast it else there will be a TypeError: o.pipe is not a function
+        const body = Readable.fromWeb(response.body);
+        return {
+            body: body,
+            contentType: response.headers.get("content-type") ?? undefined,
+            cacheControl: response.headers.get("cache-control") ?? undefined,
+        };
+    },
+};
+export default s3Loader;

package/dist/overrides/tagCache/dummy.js

@@ -1,6 +1,7 @@
 // We don't want to throw error on this one because we might use it when we don't need tag cache
 const dummyTagCache = {
     name: "dummy",
+    mode: "original",
     getByPath: async () => {
         return [];
     },

package/dist/overrides/tagCache/dynamodb-lite.js

@@ -47,6 +47,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {