@opennextjs/aws 3.7.7 → 3.8.0

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/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/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[]>;
@@ -58,6 +63,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.0",
   "bin": {
     "open-next": "./dist/index.js"
   },