@opennextjs/aws 3.7.7 → 3.8.1

package/dist/adapters/middleware.js

@@ -75,7 +75,9 @@ const defaultHandler = async (internalEvent, options) => {
                 };
             }
         }
-        result.headers[INTERNAL_EVENT_REQUEST_ID] = requestId;
+        if (process.env.OPEN_NEXT_REQUEST_ID_HEADER || globalThis.openNextDebug) {
+            result.headers[INTERNAL_EVENT_REQUEST_ID] = requestId;
+        }
         debug("Middleware response", result);
         return result;
     });

package/dist/build/copyTracedFiles.d.ts

@@ -1,3 +1,4 @@
+export declare function isExcluded(srcPath: string): boolean;
 interface CopyTracedFilesOptions {
     buildOutputPath: string;
     packagePath: string;

package/dist/build/copyTracedFiles.js

@@ -18,8 +18,13 @@ const EXCLUDED_PACKAGES = [
     "next/dist/compiled/babel-packages",
     "next/dist/compiled/amphtml-validator",
 ];
-function isExcluded(srcPath) {
-    return EXCLUDED_PACKAGES.some((excluded) => srcPath.match(getCrossPlatformPathRegex(`/node_modules/${excluded}/`)));
+export function isExcluded(srcPath) {
+    return EXCLUDED_PACKAGES.some((excluded) => 
+    // `pnpm` can create a symbolic link that points to the pnpm store folder
+    // This will live under `/node_modules/sharp`. We need to handle this in our regex
+    srcPath.match(getCrossPlatformPathRegex(`/node_modules/${excluded}(?:/|$)`, {
+        escape: false,
+    })));
 }
 function copyPatchFile(outputDir) {
     const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");

package/dist/build/installDeps.js

@@ -63,7 +63,7 @@ export function installDependencies(outputDir, installOptions) {
         logger.info(`Dependencies installed for ${name}`);
     }
     catch (e) {
-        logger.error(e.stdout.toString());
+        logger.error(e.toString());
         logger.error("Could not install dependencies");
     }
 }

package/dist/core/requestHandler.js

@@ -31,7 +31,7 @@ export async function openNextHandler(internalEvent, options) {
             initialHeaders.host = initialHeaders["x-forwarded-host"];
         }
         debug("internalEvent", internalEvent);
-        // These 2 will get overwritten by the routing handler if not using an external middleware
+        // These 3 will get overwritten by the routing handler if not using an external middleware
         const internalHeaders = {
             initialPath: initialHeaders[INTERNAL_HEADER_INITIAL_URL] ?? internalEvent.rawPath,
             resolvedRoutes: initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES]

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

@@ -1,2 +1,2 @@
-import type { InternalEvent, InternalResult } from "../../types/open-next";
-export declare function cacheInterceptor(event: InternalEvent): Promise<InternalEvent | InternalResult>;
+import type { InternalEvent, InternalResult, MiddlewareEvent } from "../../types/open-next";
+export declare function cacheInterceptor(event: MiddlewareEvent): Promise<InternalEvent | InternalResult>;

package/dist/core/routing/cacheInterceptor.js

@@ -103,8 +103,12 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
-        // sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
-        statusCode: cachedValue.meta?.status ?? 200,
+        // Sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
+        // Also set the status code to the rewriteStatusCode if defined
+        // This can happen in handleMiddleware in routingHandler.
+        // `NextResponse.rewrite(url, { status: xxx})
+        // The rewrite status code should take precedence over the cached one
+        statusCode: event.rewriteStatusCode ?? cachedValue.meta?.status ?? 200,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
         headers: {
@@ -209,7 +213,7 @@ export async function cacheInterceptor(event) {
                     const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
                     return {
                         type: "core",
-                        statusCode: cachedData.value.meta?.status ?? 200,
+                        statusCode: event.rewriteStatusCode ?? cachedData.value.meta?.status ?? 200,
                         body: toReadableStream(cachedData.value.body, isBinary),
                         headers: {
                             ...cacheControl,

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

@@ -1,9 +1,4 @@
-import type { InternalEvent, InternalResult } from "../../types/open-next.js";
-type MiddlewareEvent = InternalEvent & {
-    responseHeaders?: Record<string, string | string[]>;
-    isExternalRewrite?: boolean;
-    rewriteStatusCode?: number;
-};
+import type { InternalEvent, InternalResult, MiddlewareEvent } from "../../types/open-next.js";
 type Middleware = (request: Request) => Response | Promise<Response>;
 type MiddlewareLoader = () => Promise<{
     default: Middleware;

package/dist/core/routing/middleware.js

@@ -151,6 +151,6 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         cookies: internalEvent.cookies,
         remoteAddress: internalEvent.remoteAddress,
         isExternalRewrite,
-        rewriteStatusCode: statusCode,
+        rewriteStatusCode: rewriteUrl && !isExternalRewrite ? statusCode : undefined,
     };
 }

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

@@ -3,6 +3,7 @@ import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { FunctionsConfigManifest, MiddlewareManifest } from "../../types/next-types";
 import type { InternalEvent, InternalResult, RoutingResult, StreamCreator } from "../../types/open-next.js";
+import { ReadableStream } from "node:stream/web";
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -1,9 +1,9 @@
 import crypto from "node:crypto";
 import { parse as parseQs, stringify as stringifyQs } from "node:querystring";
-import { Readable } from "node:stream";
 import { BuildId, HtmlPages, NextConfig } from "../../adapters/config/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import { getQueryFromIterator, parseHeaders } from "../../http/util.js";
+import { ReadableStream } from "node:stream/web";
 import { debug, error } from "../../adapters/logger.js";
 import { isBinaryContentType } from "../../utils/binary.js";
 import { localizePath } from "./i18n/index.js";
@@ -84,9 +84,15 @@ export function convertRes(res) {
     const headers = parseHeaders(res.getFixedHeaders());
     const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
         !!headers["content-encoding"];
-    // We cannot convert the OpenNextNodeResponse to a ReadableStream directly
-    // You can look in the `aws-lambda.ts` file for some context
-    const body = Readable.toWeb(Readable.from(res.getBody()));
+    const body = new ReadableStream({
+        pull(controller) {
+            if (!res._chunks || res._chunks.length === 0) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(res._chunks.shift());
+        },
+    });
     return {
         type: "core",
         statusCode,

package/dist/core/routingHandler.js

@@ -79,10 +79,20 @@ export default async function routingHandler(event, { assetResolver }) {
         if (isInternalResult(middlewareEventOrResult)) {
             return middlewareEventOrResult;
         }
-        headers = {
-            ...middlewareEventOrResult.responseHeaders,
-            ...headers,
-        };
+        const middlewareHeadersPrioritized = globalThis.openNextConfig.dangerous
+            ?.middlewareHeadersOverrideNextConfigHeaders ?? false;
+        if (middlewareHeadersPrioritized) {
+            headers = {
+                ...headers,
+                ...middlewareEventOrResult.responseHeaders,
+            };
+        }
+        else {
+            headers = {
+                ...middlewareEventOrResult.responseHeaders,
+                ...headers,
+            };
+        }
         let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
         eventOrResult = middlewareEventOrResult;
         if (!isExternalRewrite) {

package/dist/http/openNextResponse.d.ts

@@ -11,10 +11,11 @@ export declare class OpenNextNodeResponse extends Transform implements ServerRes
     statusCode: number;
     statusMessage: string;
     headers: OutgoingHttpHeaders;
-    private _cookies;
-    private responseStream?;
     headersSent: boolean;
     _chunks: Buffer[];
+    private _cookies;
+    private responseStream?;
+    private bodyLength;
     strictContentLength: boolean;
     assignSocket(_socket: Socket): void;
     detachSocket(_socket: Socket): void;

package/dist/http/openNextResponse.js

@@ -12,10 +12,11 @@ export class OpenNextNodeResponse extends Transform {
     statusCode;
     statusMessage = "";
     headers = {};
-    _cookies = [];
-    responseStream;
     headersSent = false;
     _chunks = [];
+    _cookies = [];
+    responseStream;
+    bodyLength = 0;
     // To comply with the ServerResponse interface :
     strictContentLength = false;
     assignSocket(_socket) {
@@ -221,7 +222,12 @@ export class OpenNextNodeResponse extends Transform {
         return Buffer.concat(this._chunks);
     }
     _internalWrite(chunk, encoding) {
-        this._chunks.push(Buffer.from(chunk, encoding));
+        const buffer = Buffer.from(chunk, encoding);
+        this.bodyLength += buffer.length;
+        if (this.streamCreator?.retainChunks !== false) {
+            // Avoid keeping chunks around when the `StreamCreator` supports it to save memory
+            this._chunks.push(buffer);
+        }
         this.push(chunk, encoding);
         this.streamCreator?.onWrite?.();
     }
@@ -237,19 +243,18 @@ export class OpenNextNodeResponse extends Transform {
             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
+        // We may want to reconsider this in the future, it might be interesting 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.streamCreator?.onFinish?.(this.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 &&
+        if (this.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
@@ -283,8 +288,10 @@ export class OpenNextNodeResponse extends Transform {
         return (Array.isArray(values) ? values : [values]).map((value) => value.toString());
     }
     send() {
-        const body = this.getBody();
-        this.end(body);
+        for (const chunk of this._chunks) {
+            this.write(chunk);
+        }
+        this.end();
     }
     body(value) {
         this.write(value);

package/dist/http/util.js

@@ -1,3 +1,4 @@
+import logger from "../logger";
 export const parseHeaders = (headers) => {
     const result = {};
     if (!headers) {
@@ -7,7 +8,26 @@ export const parseHeaders = (headers) => {
         if (value === undefined) {
             continue;
         }
-        result[key.toLowerCase()] = convertHeader(value);
+        const keyLower = key.toLowerCase();
+        /**
+         * Next can return an Array for the Location header when you return null from a get in the cacheHandler on a page that has a redirect()
+         * We dont want to merge that into a comma-separated string
+         * If they are the same just return one of them
+         * Otherwise return the last one
+         * See: https://github.com/opennextjs/opennextjs-cloudflare/issues/875#issuecomment-3258248276
+         * and https://github.com/opennextjs/opennextjs-aws/pull/977#issuecomment-3261763114
+         */
+        if (keyLower === "location" && Array.isArray(value)) {
+            if (value[0] === value[1]) {
+                result[keyLower] = value[0];
+            }
+            else {
+                logger.warn("Multiple different values for Location header found. Using the last one");
+                result[keyLower] = value[value.length - 1];
+            }
+            continue;
+        }
+        result[keyLower] = convertHeader(value);
     }
     return result;
 };

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

@@ -42,6 +42,8 @@ const handler = async (handler, converter) => async (request, env, ctx, abortSig
         // Ensures that the response we pass to NextServer is aborted if the request is aborted
         // By doing this `request.signal.onabort` will work in route handlers
         abortSignal: abortSignal,
+        // There is no need to retain the chunks that were pushed to the response stream.
+        retainChunks: false,
     };
     ctx.waitUntil(handler(internalEvent, {
         streamCreator,

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

@@ -15,6 +15,11 @@ export type InternalEvent = {
     readonly cookies: Record<string, string>;
     readonly remoteAddress: string;
 } & BaseEventOrResult<"core">;
+export type MiddlewareEvent = InternalEvent & {
+    responseHeaders?: Record<string, string | string[]>;
+    isExternalRewrite?: boolean;
+    rewriteStatusCode?: number;
+};
 export type InternalResult = {
     statusCode: number;
     headers: Record<string, string | string[]>;
@@ -31,6 +36,18 @@ export interface StreamCreator {
     onWrite?: () => void;
     onFinish?: (length: number) => void;
     abortSignal?: AbortSignal;
+    /**
+     * Normally there is no need to retain the chunks that have been pushed to the response stream.
+     *
+     * However some implementations use a fake `StreamCreator` and expect the chunks to be retained.
+     * When your stream controller implementation doesn't need to retain the chunk, you can set this
+     * to `false` to reduce memory usage.
+     *
+     * @see https://github.com/opennextjs/opennextjs-aws/blob/main/packages/open-next/src/overrides/wrappers/aws-lambda.ts
+     *
+     * @default true for backward compatibility.
+     */
+    retainChunks?: boolean;
 }
 export type WaitUntil = (promise: Promise<void>) => void;
 export interface DangerousOptions {
@@ -58,6 +75,16 @@ export interface DangerousOptions {
      * This is executed for every request and after next config headers and middleware has executed.
      */
     headersAndCookiesPriority?: (event: InternalEvent) => "middleware" | "handler";
+    /**
+     * Configuration option to prioritize headers set via middleware over headers set via the option in the Next config.
+     *
+     * The default will change to 'true' in v4.
+     *
+     * See also {@link https://nextjs.org/docs/app/api-reference/file-conventions/middleware#execution-order}
+     *
+     * @default false
+     */
+    middlewareHeadersOverrideNextConfigHeaders?: boolean;
 }
 export type BaseOverride = {
     name: string;

package/dist/utils/cache.js

@@ -13,7 +13,9 @@ export async function hasBeenRevalidated(key, tags, cacheEntry) {
     }
     const lastModified = cacheEntry.lastModified ?? Date.now();
     if (globalThis.tagCache.mode === "nextMode") {
-        return await globalThis.tagCache.hasBeenRevalidated(tags, lastModified);
+        return tags.length === 0
+            ? false
+            : await globalThis.tagCache.hasBeenRevalidated(tags, lastModified);
     }
     // TODO: refactor this, we should introduce a new method in the tagCache interface so that both implementations use hasBeenRevalidated
     const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
@@ -25,7 +27,9 @@ export function getTagsFromValue(value) {
     }
     // The try catch is necessary for older version of next.js that may fail on this
     try {
-        return value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
+        const cacheTags = value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
+        delete value.meta?.headers?.["x-next-cache-tags"];
+        return cacheTags;
     }
     catch (e) {
         return [];

package/package.json

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