@opennextjs/aws 3.2.1 → 3.2.2

package/dist/core/routing/matcher.js

@@ -59,30 +59,22 @@ const computeParamHas = (headers, cookies, query) => (has) => {
     }
 };
 function convertMatch(match, toDestination, destination) {
-    if (match) {
-        const { params } = match;
-        const isUsingParams = Object.keys(params).length > 0;
-        if (isUsingParams) {
-            return toDestination(params);
-        }
-        else {
-            return destination;
-        }
-    }
-    else {
+    if (!match) {
         return destination;
     }
+    const { params } = match;
+    const isUsingParams = Object.keys(params).length > 0;
+    return isUsingParams ? toDestination(params) : destination;
 }
-export function addNextConfigHeaders(event, configHeaders) {
-    const addedHeaders = {};
-    if (!configHeaders)
-        return addedHeaders;
-    const { rawPath, headers, query, cookies } = event;
-    const matcher = routeHasMatcher(headers, cookies, query);
+export function getNextConfigHeaders(event, configHeaders) {
+    if (!configHeaders) {
+        return {};
+    }
+    const matcher = routeHasMatcher(event.headers, event.cookies, event.query);
     const requestHeaders = {};
     const localizedRawPath = localizePath(event);
     for (const { headers, has, missing, regex, source, locale, } of configHeaders) {
-        const path = locale === false ? rawPath : localizedRawPath;
+        const path = locale === false ? event.rawPath : localizedRawPath;
         if (new RegExp(regex).test(path) &&
             checkHas(matcher, has) &&
             checkHas(matcher, missing, true)) {
@@ -95,7 +87,7 @@ export function addNextConfigHeaders(event, configHeaders) {
                     requestHeaders[key] = value;
                 }
                 catch {
-                    debug("Error matching header ", h.key, " with value ", h.value);
+                    debug(`Error matching header ${h.key} with value ${h.value}`);
                     requestHeaders[h.key] = h.value;
                 }
             });
@@ -132,16 +124,16 @@ export function handleRewrites(event, rewrites) {
         const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
         const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
         const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
-        let params = {
+        const params = {
             // params for the source
             ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
             // params for the missing
             ...rewrite.missing?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
@@ -200,7 +192,7 @@ function handleTrailingSlashRedirect(event) {
         };
         // eslint-disable-next-line sonarjs/elseif-without-else
     }
-    else if (!NextConfig.trailingSlash &&
+    if (!NextConfig.trailingSlash &&
         event.rawPath.endsWith("/") &&
         event.rawPath !== "/") {
         const headersLocation = event.url.split("?");
@@ -214,8 +206,7 @@ function handleTrailingSlashRedirect(event) {
             isBase64Encoded: false,
         };
     }
-    else
-        return false;
+    return false;
 }
 export function handleRedirects(event, redirects) {
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
@@ -273,7 +264,7 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
         return routeRegexExp.test(rawPath);
     });
     const locales = NextConfig.i18n?.locales;
-    const routesAlreadyHaveLocale = (locales !== undefined && locales.includes(rawPath.split("/")[1])) ||
+    const routesAlreadyHaveLocale = locales?.includes(rawPath.split("/")[1]) ||
         // If we don't use locales, we don't need to add the default locale
         locales === undefined;
     const localizedPath = routesAlreadyHaveLocale

package/dist/core/routing/middleware.js

@@ -21,35 +21,36 @@ function defaultMiddlewareLoader() {
 // @returns undefined | res.end()
 //    if res.end() is return, the parent needs to return and not process next server
 export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
-    const { query } = internalEvent;
-    const normalizedPath = localizePath(internalEvent);
+    const headers = internalEvent.headers;
+    // We bypass the middleware if the request is internal
+    if (headers["x-isr"])
+        return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
+    const normalizedPath = localizePath(internalEvent);
     const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
     if (!hasMatch)
         return internalEvent;
-    // We bypass the middleware if the request is internal
-    if (internalEvent.headers["x-isr"])
-        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 = internalEvent.headers.host
-        ? `${protocol}//${internalEvent.headers.host}`
+    const host = headers.host
+        ? `${protocol}//${headers.host}`
         : "http://localhost:3000";
     const initialUrl = new URL(normalizedPath, host);
-    initialUrl.search = convertToQueryString(query);
+    initialUrl.search = convertToQueryString(internalEvent.query);
     const url = initialUrl.toString();
     const middleware = await middlewareLoader();
     const result = await middleware.default({
+        // `geo` is pre Next 15.
         geo: {
-            city: internalEvent.headers["x-open-next-city"],
-            country: internalEvent.headers["x-open-next-country"],
-            region: internalEvent.headers["x-open-next-region"],
-            latitude: internalEvent.headers["x-open-next-latitude"],
-            longitude: internalEvent.headers["x-open-next-longitude"],
+            city: headers["x-open-next-city"],
+            country: headers["x-open-next-country"],
+            region: headers["x-open-next-region"],
+            latitude: headers["x-open-next-latitude"],
+            longitude: headers["x-open-next-longitude"],
         },
-        headers: internalEvent.headers,
+        headers,
         method: internalEvent.method || "GET",
         nextConfig: {
             basePath: NextConfig.basePath,
@@ -127,9 +128,9 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
             const rewriteUrlObject = new URL(rewriteUrl);
             newUrl = rewriteUrlObject.pathname;
             // Reset the query params if the middleware is a rewrite
-            if (middlewareQueryString["__nextDataReq"]) {
+            if (middlewareQueryString.__nextDataReq) {
                 middlewareQueryString = {
-                    __nextDataReq: middlewareQueryString["__nextDataReq"],
+                    __nextDataReq: middlewareQueryString.__nextDataReq,
                 };
             }
             else {

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

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage, StreamCreator } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
@@ -59,16 +56,6 @@ export declare function unescapeRegex(str: string): string;
  * @__PURE__
  */
 export declare function convertBodyToReadableStream(method: string, body?: string | Buffer): ReadableStream<any> | undefined;
-/**
- *
- * @__PURE__
- */
-export declare function proxyRequest(internalEvent: InternalEvent, res: OpenNextNodeResponse): Promise<void>;
-declare global {
-    var openNextDebug: boolean;
-    var openNextVersion: string;
-    var lastModified: Record<string, number>;
-}
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -24,7 +24,8 @@ export function convertFromQueryString(query) {
     const queryParts = query.split("&");
     return queryParts.reduce((acc, part) => {
         const [key, value] = part.split("=");
-        return { ...acc, [key]: value };
+        acc[key] = value;
+        return acc;
     }, {});
 }
 /**
@@ -128,45 +129,20 @@ export function getMiddlewareMatch(middlewareManifest) {
  * @__PURE__
  */
 export function escapeRegex(str) {
-    let path = str.replace(/\(\.\)/g, "_µ1_");
-    path = path.replace(/\(\.{2}\)/g, "_µ2_");
-    path = path.replace(/\(\.{3}\)/g, "_µ3_");
-    return path;
+    return str
+        .replaceAll("(.)", "_µ1_")
+        .replaceAll("(..)", "_µ2_")
+        .replaceAll("(...)", "_µ3_");
 }
 /**
  *
  * @__PURE__
  */
 export function unescapeRegex(str) {
-    let path = str.replace(/_µ1_/g, "(.)");
-    path = path.replace(/_µ2_/g, "(..)");
-    path = path.replace(/_µ3_/g, "(...)");
-    return path;
-}
-/**
- *
- * @__PURE__
- */
-function filterHeadersForProxy(headers) {
-    const filteredHeaders = {};
-    const disallowedHeaders = [
-        "host",
-        "connection",
-        "via",
-        "x-cache",
-        "transfer-encoding",
-        "content-encoding",
-        "content-length",
-    ];
-    Object.entries(headers).forEach(([key, value]) => {
-        const lowerKey = key.toLowerCase();
-        if (disallowedHeaders.includes(lowerKey) || lowerKey.startsWith("x-amz"))
-            return;
-        else {
-            filteredHeaders[key] = value?.toString() ?? "";
-        }
-    });
-    return filteredHeaders;
+    return str
+        .replaceAll("_µ1_", "(.)")
+        .replaceAll("_µ2_", "(..)")
+        .replaceAll("_µ3_", "(...)");
 }
 /**
  * @__PURE__
@@ -184,50 +160,6 @@ export function convertBodyToReadableStream(method, body) {
     });
     return readable;
 }
-/**
- *
- * @__PURE__
- */
-export async function proxyRequest(internalEvent, res) {
-    const { url, headers, method, body } = internalEvent;
-    const request = await import("node:https").then((m) => m.request);
-    debug("proxyRequest", url);
-    await new Promise((resolve, reject) => {
-        const filteredHeaders = filterHeadersForProxy(headers);
-        debug("filteredHeaders", filteredHeaders);
-        const req = request(url, {
-            headers: filteredHeaders,
-            method,
-            rejectUnauthorized: false,
-        }, (_res) => {
-            res.writeHead(_res.statusCode ?? 200, filterHeadersForProxy(_res.headers));
-            if (_res.headers["content-encoding"] === "br") {
-                _res.pipe(require("node:zlib").createBrotliDecompress()).pipe(res);
-            }
-            else if (_res.headers["content-encoding"] === "gzip") {
-                _res.pipe(require("node:zlib").createGunzip()).pipe(res);
-            }
-            else {
-                _res.pipe(res);
-            }
-            _res.on("error", (e) => {
-                error("proxyRequest error", e);
-                res.end();
-                reject(e);
-            });
-            res.on("finish", () => {
-                resolve();
-            });
-        });
-        if (body && method !== "GET" && method !== "HEAD") {
-            req.write(body);
-        }
-        req.end();
-    });
-    // console.log("result", result);
-    // res.writeHead(result.status, resHeaders);
-    // res.end(await result.text());
-}
 var CommonHeaders;
 (function (CommonHeaders) {
     CommonHeaders["CACHE_CONTROL"] = "cache-control";
@@ -247,7 +179,8 @@ export function fixCacheHeaderForHtmlPages(rawPath, headers) {
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
     }
-    // WORKAROUND: `NextServer` does not set cache headers for HTML pages — https://github.com/serverless-stack/open-next#workaround-nextserver-does-not-set-cache-headers-for-html-pages
+    // 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)) {
         headers[CommonHeaders.CACHE_CONTROL] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
@@ -279,7 +212,8 @@ export function addOpenNextHeader(headers) {
     }
     if (globalThis.openNextDebug) {
         headers["X-OpenNext-Version"] = globalThis.openNextVersion;
-        headers["X-OpenNext-RequestId"] = globalThis.__als.getStore()?.requestId;
+        headers["X-OpenNext-RequestId"] =
+            globalThis.__openNextAls.getStore()?.requestId;
     }
 }
 /**
@@ -310,13 +244,13 @@ 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.__als.getStore()?.requestId ?? "";
+            const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
             const lastModified = globalThis.lastModified[requestId] > 0
                 ? globalThis.lastModified[requestId]
                 : "";
             // 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"] ?? "";
+            const etag = headers.etag ?? headers.ETag ?? "";
             await globalThis.queue.send({
                 MessageBody: { host, url: revalidateUrl },
                 MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${etag}`),
@@ -338,19 +272,22 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
 export function generateMessageGroupId(rawPath) {
     let a = cyrb128(rawPath);
     // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
-    var t = (a += 0x6d2b79f5);
+    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 = parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
+    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, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
+    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);
@@ -362,6 +299,7 @@ function cyrb128(str) {
     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;
 }
@@ -375,7 +313,7 @@ export function fixISRHeaders(headers) {
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
     }
-    const requestId = globalThis.__als.getStore()?.requestId ?? "";
+    const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
     const _lastModified = globalThis.lastModified[requestId] ?? 0;
     if (headers[CommonHeaders.NEXT_CACHE] === "HIT" && _lastModified > 0) {
         // calculate age
@@ -387,7 +325,7 @@ export function fixISRHeaders(headers) {
         if (typeof cacheControl !== "string")
             return;
         const match = cacheControl.match(regex);
-        const sMaxAge = match ? parseInt(match[1]) : undefined;
+        const sMaxAge = match ? Number.parseInt(match[1]) : undefined;
         // 31536000 is the default s-maxage value for SSG pages
         if (sMaxAge && sMaxAge !== 31536000) {
             const remainingTtl = Math.max(sMaxAge - age, 1);

package/dist/core/routingHandler.d.ts

@@ -1,4 +1,6 @@
 import type { InternalEvent, InternalResult, Origin } from "../types/open-next";
+export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
+export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
 export interface MiddlewareOutputEvent {
     internalEvent: InternalEvent;
     isExternalRewrite: boolean;

package/dist/core/routingHandler.js

@@ -1,18 +1,20 @@
 import { BuildId, ConfigHeaders, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
 import { debug } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
-import { addNextConfigHeaders, fixDataPage, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
+import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
+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("|")})?`
+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
+const optionalBasepathPrefixRegex = RoutesManifest.basePath
     ? `^${RoutesManifest.basePath}/?`
     : "^/";
 // Add the basePath prefix to the api routes
-const apiPrefix = !!RoutesManifest.basePath
+const apiPrefix = RoutesManifest.basePath
     ? `${RoutesManifest.basePath}/api`
     : "/api";
 const staticRegexp = RoutesManifest.routes.static.map((route) => new RegExp(route.regex
@@ -21,16 +23,34 @@ const staticRegexp = RoutesManifest.routes.static.map((route) => new RegExp(rout
 const dynamicRegexp = RoutesManifest.routes.dynamic.map((route) => new RegExp(route.regex
     .replace("^/", optionalLocalePrefixRegex)
     .replace("^/", optionalBasepathPrefixRegex)));
+// Geolocation headers starting from Nextjs 15
+// See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
+const geoHeaderToNextHeader = {
+    "x-open-next-city": "x-vercel-ip-city",
+    "x-open-next-country": "x-vercel-ip-country",
+    "x-open-next-region": "x-vercel-ip-country-region",
+    "x-open-next-latitude": "x-vercel-ip-latitude",
+    "x-open-next-longitude": "x-vercel-ip-longitude",
+};
 function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = true) {
+    const keyPrefix = setPrefix ? MIDDLEWARE_HEADER_PREFIX : "";
     Object.entries(middlewareHeaders).forEach(([key, value]) => {
         if (value) {
-            eventHeaders[`${setPrefix ? "x-middleware-response-" : ""}${key}`] =
-                Array.isArray(value) ? value.join(",") : value;
+            eventHeaders[keyPrefix + key] = Array.isArray(value)
+                ? value.join(",")
+                : value;
         }
     });
 }
 export default async function routingHandler(event) {
-    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders);
+    // Add Next geo headers
+    for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
+        const value = event.headers[openNextGeoName];
+        if (value) {
+            event.headers[nextGeoName] = value;
+        }
+    }
+    const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
     let internalEvent = fixDataPage(event, BuildId);
     if ("statusCode" in internalEvent) {
         return internalEvent;
@@ -45,10 +65,8 @@ export default async function routingHandler(event) {
     if ("statusCode" in middleware) {
         return middleware;
     }
-    else {
-        middlewareResponseHeaders = middleware.responseHeaders || {};
-        internalEvent = middleware;
-    }
+    middlewareResponseHeaders = middleware.responseHeaders || {};
+    internalEvent = middleware;
     // At this point internalEvent is an InternalEvent or a MiddlewareOutputEvent
     let isExternalRewrite = middleware.externalRewrite ?? false;
     if (!isExternalRewrite) {

package/dist/core/util.js

@@ -5,7 +5,8 @@ import { AppPathsManifestKeys, NextConfig, RoutesManifest, } from "../adapters/c
 import NextServer from "next/dist/server/next-server.js";
 import { debug } from "../adapters/logger.js";
 import { applyOverride as applyNextjsRequireHooksOverride, overrideHooks as overrideNextjsRequireHooks, } from "./require-hooks.js";
-// WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React — https://github.com/serverless-stack/open-next#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
+// WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled Reac
+// See https://opennext.js.org/aws/v2/advanced/workaround#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
 // Step 1: Need to override the require hooks for React before Next.js server
 //         overrides them with prebundled ones in the case of app dir
 // Step 2: Import Next.js server
@@ -31,7 +32,7 @@ export const requestHandler = new NextServer.default({
         // our own cache handler to store the cache on S3.
         //#override stableIncrementalCache
         cacheHandler: cacheHandlerPath,
-        cacheMaxMemorySize: 0,
+        cacheMaxMemorySize: 0, // We need to disable memory cache
         //#endOverride
         experimental: {
             ...NextConfig.experimental,
@@ -62,7 +63,8 @@ export function loadMiddlewareManifest(nextDir) {
 }
 //#override setNextjsPrebundledReact
 export function setNextjsPrebundledReact(rawPath) {
-    // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React — https://github.com/serverless-stack/open-next#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
+    // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React
+    // See https://opennext.js.org/aws/v2/advanced/workaround#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
     const routes = [
         ...RoutesManifest.routes.static,
         ...RoutesManifest.routes.dynamic,

package/dist/helpers/withSST.d.ts

@@ -44,7 +44,7 @@ export declare function withSST<Fn extends Record<string, SSTCompatibleSplittedF
     functions?: Fn | undefined;
     middleware?: {
         external: true;
-    } | undefined;
+    };
     dangerous?: import("../types/open-next").DangerousOptions | undefined;
     buildCommand?: string | undefined;
     buildOutputPath?: string | undefined;

package/dist/http/openNextResponse.d.ts

@@ -1,12 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "http";
-import type { Socket } from "net";
-import type { TransformCallback, Writable } from "stream";
-import { Transform } from "stream";
+import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "node:http";
+import type { Socket } from "node:net";
+import type { TransformCallback, Writable } from "node:stream";
+import { Transform } from "node:stream";
 export interface StreamCreator {
     writeHeaders(prelude: {
         statusCode: number;
@@ -18,6 +13,7 @@ export interface StreamCreator {
 }
 export declare class OpenNextNodeResponse extends Transform implements ServerResponse {
     private fixHeaders;
+    private onEnd;
     private streamCreator?;
     private initialHeaders?;
     statusCode: number;

package/dist/http/openNextResponse.js

@@ -1,4 +1,4 @@
-import { Transform } from "stream";
+import { Transform } from "node:stream";
 import { debug } from "../adapters/logger";
 import { parseCookies, parseHeaders } from "./util";
 const SET_COOKIE_HEADER = "set-cookie";
@@ -6,6 +6,7 @@ const CANNOT_BE_USED = "This cannot be used in OpenNext";
 // We only need to implement the methods that are used by next.js
 export class OpenNextNodeResponse extends Transform {
     fixHeaders;
+    onEnd;
     streamCreator;
     initialHeaders;
     statusCode;
@@ -53,20 +54,9 @@ export class OpenNextNodeResponse extends Transform {
     constructor(fixHeaders, onEnd, streamCreator, initialHeaders) {
         super();
         this.fixHeaders = fixHeaders;
+        this.onEnd = onEnd;
         this.streamCreator = streamCreator;
         this.initialHeaders = initialHeaders;
-        this.once("finish", () => {
-            if (!this.headersSent) {
-                this.flushHeaders();
-            }
-            // In some cases we might not have a store i.e. for example in the image optimization function
-            // We may want to reconsider this in the future, it might be intersting to have access to this store everywhere
-            globalThis.__als
-                ?.getStore()
-                ?.pendingPromiseRunner.add(onEnd(this.headers));
-            const bodyLength = this.getBody().length;
-            this.streamCreator?.onFinish(bodyLength);
-        });
     }
     // Necessary for next 12
     // We might have to implement all the methods here
@@ -122,7 +112,8 @@ export class OpenNextNodeResponse extends Transform {
         this.headersSent = true;
         // Initial headers should be merged with the new headers
         // These initial headers are the one created either in the middleware or in next.config.js
-        const mergeHeadersPriority = globalThis.__als?.getStore()?.mergeHeadersPriority ?? "middleware";
+        const mergeHeadersPriority = globalThis.__openNextAls?.getStore()?.mergeHeadersPriority ??
+            "middleware";
         if (this.initialHeaders) {
             this.headers =
                 mergeHeadersPriority === "middleware"
@@ -134,7 +125,7 @@ export class OpenNextNodeResponse extends Transform {
                         ...this.initialHeaders,
                         ...this.headers,
                     };
-            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER] ?? []);
+            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER]);
             this._cookies =
                 mergeHeadersPriority === "middleware"
                     ? [...this._cookies, ...initialCookies]
@@ -162,14 +153,12 @@ export class OpenNextNodeResponse extends Transform {
         if (!this.hasHeader(key)) {
             return this.setHeader(key, value);
         }
-        else {
-            const existingHeader = this.getHeader(key);
-            const toAppend = Array.isArray(value) ? value : [value];
-            const newValue = Array.isArray(existingHeader)
-                ? [...existingHeader, ...toAppend]
-                : [existingHeader, ...toAppend];
-            return this.setHeader(key, newValue);
-        }
+        const existingHeader = this.getHeader(key);
+        const toAppend = Array.isArray(value) ? value : [value];
+        const newValue = Array.isArray(existingHeader)
+            ? [...existingHeader, ...toAppend]
+            : [existingHeader, ...toAppend];
+        return this.setHeader(key, newValue);
     }
     writeHead(statusCode, statusMessage, headers) {
         let _headers = headers;
@@ -227,15 +216,24 @@ export class OpenNextNodeResponse extends Transform {
         this._internalWrite(chunk, encoding);
         callback();
     }
-    //This is only here because of aws broken streaming implementation.
-    //Hopefully one day they will be able to give us a working streaming implementation in lambda for everyone
-    //If you're lucky you have a working streaming implementation in your aws account and don't need this
-    //If not you can set the OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE env variable to true
-    //BE CAREFUL: Aws keeps rolling out broken streaming implementations even on accounts that had working ones before
-    //This is not dependent on the node runtime used
-    //There is another known issue with aws lambda streaming where the request reach the lambda only way after the request has been sent by the client. For this there is absolutely nothing we can do, contact aws support if that's your case
     _flush(callback) {
-        if (this.getBody().length < 1 &&
+        if (!this.headersSent) {
+            this.flushHeaders();
+        }
+        // In some cases we might not have a store i.e. for example in the image optimization function
+        // We may want to reconsider this in the future, it might be intersting to have access to this store everywhere
+        globalThis.__openNextAls
+            ?.getStore()
+            ?.pendingPromiseRunner.add(this.onEnd(this.headers));
+        const bodyLength = this.getBody().length;
+        this.streamCreator?.onFinish(bodyLength);
+        //This is only here because of aws broken streaming implementation.
+        //Hopefully one day they will be able to give us a working streaming implementation in lambda for everyone
+        //If you're lucky you have a working streaming implementation in your aws account and don't need this
+        //If not you can set the OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE env variable to true
+        //BE CAREFUL: Aws keeps rolling out broken streaming implementations even on accounts that had working ones before
+        //This is not dependent on the node runtime used
+        if (bodyLength === 0 &&
             // We use an env variable here because not all aws account have the same behavior
             // On some aws accounts the response will hang if the body is empty
             // We are modifying the response body here, this is not a good practice

package/dist/http/request.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import http from "node:http";
 export declare class IncomingMessage extends http.IncomingMessage {
     constructor({ method, url, headers, body, remoteAddress, }: {