@opennextjs/aws 4.1.1 → 4.1.2

package/dist/adapters/cache.js

@@ -1,5 +1,6 @@
 import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
+import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders";
 import { compareSemver } from "../utils/semver";
 import { debug, error, warn } from "./logger";
 export const SOFT_TAG_PREFIX = "_N_T_/";
@@ -440,7 +441,7 @@ export default class Cache {
         // is shared with headers that can legitimately repeat, so we narrow on `typeof` here.
         // Next.js guards the same way when it reads the header back.
         const pageCacheTags = data?.kind === "PAGE" || data?.kind === "APP_PAGE"
-            ? data.headers?.["x-next-cache-tags"]
+            ? data.headers?.[CACHE_TAGS_HEADER]
             : undefined;
         const derivedTags = data?.kind === "FETCH"
             ? //@ts-expect-error - On older versions of next, ctx was a number, but for these cases we use data?.data?.tags

package/dist/adapters/middleware.js

@@ -1,3 +1,4 @@
+import { ISR_HEADER } from "../utils/cacheHeaders";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
@@ -21,7 +22,7 @@ const defaultHandler = async (internalEvent, options) => {
     const requestId = Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the external middleware
     return runWithOpenNextRequestContext({
-        isISRRevalidation: internalEvent.headers["x-isr"] === "1",
+        isISRRevalidation: internalEvent.headers[ISR_HEADER] === "1",
         waitUntil: options?.waitUntil,
         requestId,
     }, async () => {

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.js

@@ -17,18 +17,19 @@ export async function optimizeImage(headers, imageParams, nextConfig, handleRequ
      *
      * https://github.com/vercel/next.js/blob/bfe2ab4/packages/next/src/server/image-optimizer.ts#L711
      */
+    // Next 16 rejects upstream hosts resolving to private IPs unless the user
+    // opts out with `images.dangerouslyAllowLocalIP` — forward their setting
+    // instead of always disabling the opt-out.
+    const dangerouslyAllowLocalIP = Boolean(nextConfig.images?.dangerouslyAllowLocalIP);
     const callFetchExternalImage = () => {
         const version = globalThis.nextVersion;
-        // v16.1.5+
         if (compareSemver(version, ">=", "16.1.5")) {
-            return fetchExternalImage(href, false, maximumResponseBody);
+            return fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody);
         }
-        // v16.0.0–v16.1.4
         if (compareSemver(version, ">=", "16")) {
             // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
-            return fetchExternalImage(href, false);
+            return fetchExternalImage(href, dangerouslyAllowLocalIP);
         }
-        // v15.5.10–v15.x
         if (compareSemver(version, ">=", "15.5.10")) {
             // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
             return fetchExternalImage(href, maximumResponseBody);

package/dist/adapters/revalidate.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import https from "node:https";
 import path from "node:path";
 import { createGenericHandler } from "../core/createGenericHandler.js";
+import { ISR_HEADER, NEXTJS_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, } from "../utils/cacheHeaders.js";
 import { debug, error } from "./logger.js";
 const prerenderManifest = loadPrerenderManifest();
 const ALLOWED_STATUS_CODES = [200, 307, 308, 404];
@@ -23,8 +24,8 @@ const defaultHandler = async (event) => {
                 const req = https.request(`https://${host}${url}`, {
                     method: "HEAD",
                     headers: {
-                        "x-prerender-revalidate": prerenderManifest.preview.previewModeId,
-                        "x-isr": "1",
+                        [PRERENDER_REVALIDATE_HEADER]: prerenderManifest.preview.previewModeId,
+                        [ISR_HEADER]: "1",
                     },
                 }, (res) => {
                     debug("revalidating", {
@@ -34,7 +35,7 @@ const defaultHandler = async (event) => {
                         statusCode: res.statusCode,
                     });
                     if (!ALLOWED_STATUS_CODES.includes(res.statusCode ?? 0) ||
-                        res.headers["x-nextjs-cache"] !== "REVALIDATED") {
+                        res.headers[NEXTJS_CACHE_HEADER] !== "REVALIDATED") {
                         failedRecords.push(record);
                     }
                     resolve(res);

package/dist/build/createAssets.js

@@ -4,6 +4,7 @@ import { loadConfig } from "../adapters/config/util.js";
 import { safeParseJsonFile } from "../utils/safe-json-parse.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
+import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders.js";
 import * as buildHelper from "./helper.js";
 /**
  * Copy the static assets to the output folder
@@ -188,8 +189,8 @@ export function createCacheAssets(options) {
             buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
                 const fileContent = fs.readFileSync(absolutePath, "utf8");
                 const fileData = safeParseJsonFile(fileContent, absolutePath);
-                if (fileData?.headers?.["x-next-cache-tags"]) {
-                    fileData.headers["x-next-cache-tags"]
+                if (fileData?.headers?.[CACHE_TAGS_HEADER]) {
+                    fileData.headers[CACHE_TAGS_HEADER]
                         .split(",")
                         .forEach((tag) => {
                         // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation

package/dist/core/requestHandler.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
+import { ISR_HEADER } from "../utils/cacheHeaders";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
@@ -22,7 +23,7 @@ export async function openNextHandler(internalEvent, options) {
         : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
     return runWithOpenNextRequestContext({
-        isISRRevalidation: initialHeaders["x-isr"] === "1",
+        isISRRevalidation: initialHeaders[ISR_HEADER] === "1",
         waitUntil: options?.waitUntil,
         requestId,
     }, async () => {

package/dist/core/routing/cacheInterceptor.js

@@ -3,6 +3,7 @@ import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { isBinaryContentType } from "../../utils/binary";
 import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
+import { CACHE_CONTROL_HEADER, NO_STORE_CACHE_CONTROL, OPEN_NEXT_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, fixCacheControlForError, } from "../../utils/cacheHeaders";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
@@ -41,8 +42,8 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
     if (revalidate === 0) {
         // This one should never happen
         return {
-            "cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
-            "x-opennext-cache": "ERROR",
+            [CACHE_CONTROL_HEADER]: NO_STORE_CACHE_CONTROL,
+            [OPEN_NEXT_CACHE_HEADER]: "ERROR",
             etag,
         };
     }
@@ -77,14 +78,14 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
             });
         }
         return {
-            "cache-control": `s-maxage=${sMaxAge}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-            "x-opennext-cache": isStale ? "STALE" : "HIT",
+            [CACHE_CONTROL_HEADER]: `s-maxage=${sMaxAge}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+            [OPEN_NEXT_CACHE_HEADER]: isStale ? "STALE" : "HIT",
             etag,
         };
     }
     return {
-        "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-        "x-opennext-cache": "HIT",
+        [CACHE_CONTROL_HEADER]: `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+        [OPEN_NEXT_CACHE_HEADER]: "HIT",
         etag,
     };
 }
@@ -168,23 +169,30 @@ async function generateResult(event, localizedPath, cachedValue, lastModified, i
         return undefined;
     }
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified, isStaleFromTagCache);
+    // 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
+    const statusCode = event.rewriteStatusCode ?? cachedValue.meta?.status ?? 200;
+    const headers = {
+        ...cacheControl,
+        "content-type": type,
+        ...cachedValue.meta?.headers,
+        vary: VARY_HEADER,
+        ...additionalHeaders,
+    };
+    // Applied last so that it wins over both the computed cache control and the one
+    // that could be stored in the entry's own headers. This is the same override the
+    // server path applies in `OpenNextNodeResponse.fixHeadersForError`, which the
+    // interceptor bypasses by returning a result directly.
+    fixCacheControlForError(headers, statusCode);
     return {
         type: "core",
-        // 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,
+        statusCode,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
-        headers: {
-            ...cacheControl,
-            "content-type": type,
-            ...cachedValue.meta?.headers,
-            vary: VARY_HEADER,
-            ...additionalHeaders,
-        },
+        headers,
     };
 }
 /**
@@ -209,7 +217,7 @@ function decodePathParams(pathname) {
 }
 export async function cacheInterceptor(event) {
     if (Boolean(event.headers["next-action"]) ||
-        Boolean(event.headers["x-prerender-revalidate"]))
+        Boolean(event.headers[PRERENDER_REVALIDATE_HEADER]))
         return event;
     // Check for Next.js preview mode cookies
     const cookies = event.headers.cookie || "";
@@ -290,15 +298,19 @@ export async function cacheInterceptor(event) {
                 case "route": {
                     const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
+                    const statusCode = event.rewriteStatusCode ?? cachedData.value.meta?.status ?? 200;
+                    const headers = {
+                        ...cacheControl,
+                        ...cachedData.value.meta?.headers,
+                        vary: VARY_HEADER,
+                    };
+                    // See the note in `generateResult`.
+                    fixCacheControlForError(headers, statusCode);
                     return {
                         type: "core",
-                        statusCode: event.rewriteStatusCode ?? cachedData.value.meta?.status ?? 200,
+                        statusCode,
                         body: toReadableStream(cachedData.value.body, isBinary),
-                        headers: {
-                            ...cacheControl,
-                            ...cachedData.value.meta?.headers,
-                            vary: VARY_HEADER,
-                        },
+                        headers,
                         isBase64Encoded: isBinary,
                     };
                 }

package/dist/core/routing/middleware.js

@@ -1,4 +1,5 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
+import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
 import { localizePath } from "./i18n/index.js";
@@ -23,8 +24,8 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     // We bypass the middleware if the request is internal
     // We should only do that if the request has the correct `x-prerender-revalidate` header
     // The `x-prerender-revalidate` header is set at build time and should be safe to trust
-    if (headers["x-isr"] &&
-        headers["x-prerender-revalidate"] ===
+    if (headers[ISR_HEADER] &&
+        headers[PRERENDER_REVALIDATE_HEADER] ===
             PrerenderManifest?.preview?.previewModeId)
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run

package/dist/core/routing/util.js

@@ -6,6 +6,7 @@ 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 { CACHE_CONTROL_HEADER, ISR_HEADER, NEXTJS_CACHE_HEADER, NO_STORE_CACHE_CONTROL, fixCacheControlForError, } from "../../utils/cacheHeaders.js";
 import { localizePath } from "./i18n/index.js";
 import { generateMessageGroupId } from "./queue.js";
 /**
@@ -205,11 +206,6 @@ export function convertBodyToReadableStream(method, body) {
         },
     });
 }
-var CommonHeaders;
-(function (CommonHeaders) {
-    CommonHeaders["CACHE_CONTROL"] = "cache-control";
-    CommonHeaders["NEXT_CACHE"] = "x-nextjs-cache";
-})(CommonHeaders || (CommonHeaders = {}));
 /**
  *
  * @__PURE__
@@ -217,11 +213,7 @@ var CommonHeaders;
 export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // We don't want to cache error pages
     if (internalEvent.rawPath === "/404" || internalEvent.rawPath === "/500") {
-        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
-            return;
-        }
-        headers[CommonHeaders.CACHE_CONTROL] =
-            "private, no-cache, no-store, max-age=0, must-revalidate";
+        fixCacheControlForError(headers, internalEvent.rawPath === "/404" ? 404 : 500);
         return;
     }
     const localizedPath = localizePath(internalEvent);
@@ -230,7 +222,7 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // Requests containing an `x-middleware-prefetch` header must not be cached
     if (HtmlPages.includes(localizedPath) &&
         !internalEvent.headers["x-middleware-prefetch"]) {
-        headers[CommonHeaders.CACHE_CONTROL] =
+        headers[CACHE_CONTROL_HEADER] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }
 }
@@ -240,7 +232,7 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
  */
 export function fixSWRCacheHeader(headers) {
     // WORKAROUND: `NextServer` does not set correct SWR cache headers — https://github.com/sst/open-next#workaround-nextserver-does-not-set-correct-swr-cache-headers
-    let cacheControl = headers[CommonHeaders.CACHE_CONTROL];
+    let cacheControl = headers[CACHE_CONTROL_HEADER];
     if (!cacheControl)
         return;
     if (Array.isArray(cacheControl)) {
@@ -248,7 +240,7 @@ export function fixSWRCacheHeader(headers) {
     }
     if (typeof cacheControl !== "string")
         return;
-    headers[CommonHeaders.CACHE_CONTROL] = cacheControl.replace(/\bstale-while-revalidate(?!=)/, "stale-while-revalidate=2592000");
+    headers[CACHE_CONTROL_HEADER] = cacheControl.replace(/\bstale-while-revalidate(?!=)/, "stale-while-revalidate=2592000");
 }
 /**
  *
@@ -271,7 +263,7 @@ export function addOpenNextHeader(headers) {
  * @__PURE__
  */
 export async function revalidateIfRequired(host, rawPath, headers, req) {
-    if (headers[CommonHeaders.NEXT_CACHE] === "STALE") {
+    if (headers[NEXTJS_CACHE_HEADER] === "STALE") {
         // If the URL is rewritten, revalidation needs to be done on the rewritten URL.
         // - Link to Next.js doc: https://nextjs.org/docs/pages/building-your-application/data-fetching/incremental-static-regeneration#on-demand-revalidation
         // - Link to NextInternalRequestMeta: https://github.com/vercel/next.js/blob/57ab2818b93627e91c937a130fb56a36c41629c3/packages/next/src/server/request-meta.ts#L11
@@ -315,37 +307,35 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
  */
 export function fixISRHeaders(headers) {
     const sMaxAgeRegex = /s-maxage=(\d+)/;
-    const match = headers[CommonHeaders.CACHE_CONTROL]?.match(sMaxAgeRegex);
+    const match = headers[CACHE_CONTROL_HEADER]?.match(sMaxAgeRegex);
     const sMaxAge = match ? Number.parseInt(match[1]) : undefined;
     // We only apply the fix if the cache-control header contains s-maxage
     if (!sMaxAge) {
         return;
     }
-    if (headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
-        headers[CommonHeaders.CACHE_CONTROL] =
-            "private, no-cache, no-store, max-age=0, must-revalidate";
+    if (headers[NEXTJS_CACHE_HEADER] === "REVALIDATED") {
+        headers[CACHE_CONTROL_HEADER] = NO_STORE_CACHE_CONTROL;
         return;
     }
     const _lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
-    if (headers[CommonHeaders.NEXT_CACHE] === "HIT" && _lastModified > 0) {
-        debug("cache-control", headers[CommonHeaders.CACHE_CONTROL], _lastModified, Date.now());
+    if (headers[NEXTJS_CACHE_HEADER] === "HIT" && _lastModified > 0) {
+        debug("cache-control", headers[CACHE_CONTROL_HEADER], _lastModified, Date.now());
         // 31536000 is the default s-maxage value for SSG pages
         if (sMaxAge && sMaxAge !== 31536000) {
             // calculate age
             const age = Math.round((Date.now() - _lastModified) / 1000);
             const remainingTtl = Math.max(sMaxAge - age, 1);
-            headers[CommonHeaders.CACHE_CONTROL] =
+            headers[CACHE_CONTROL_HEADER] =
                 `s-maxage=${remainingTtl}, stale-while-revalidate=2592000`;
         }
     }
-    if (headers[CommonHeaders.NEXT_CACHE] !== "STALE")
+    if (headers[NEXTJS_CACHE_HEADER] !== "STALE")
         return;
     // If the cache is stale, we revalidate in the background
     // In order for CloudFront SWR to work, we set the stale-while-revalidate value to 2 seconds
     // This will cause CloudFront to cache the stale data for a short period of time while we revalidate in the background
     // Once the revalidation is complete, CloudFront will serve the fresh data
-    headers[CommonHeaders.CACHE_CONTROL] =
-        "s-maxage=2, stale-while-revalidate=2592000";
+    headers[CACHE_CONTROL_HEADER] = "s-maxage=2, stale-while-revalidate=2592000";
 }
 /**
  *
@@ -371,9 +361,8 @@ export function createServerResponse(routingResult, headers, responseStream) {
 export async function invalidateCDNOnRequest(params, headers) {
     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") {
+    const isIsrRevalidation = internalEvent.headers[ISR_HEADER] === "1";
+    if (!isIsrRevalidation && headers[NEXTJS_CACHE_HEADER] === "REVALIDATED") {
         await globalThis.cdnInvalidationHandler.invalidatePaths([
             {
                 initialPath,

package/dist/core/routingHandler.js

@@ -1,5 +1,6 @@
 import { BuildId, ConfigHeaders, NextConfig, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
+import { NO_STORE_CACHE_CONTROL } from "../utils/cacheHeaders";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
@@ -169,7 +170,7 @@ export default async function routingHandler(event, { assetResolver }) {
                 url: constructNextUrl(eventOrResult.url, "/404"),
                 headers: {
                     ...eventOrResult.headers,
-                    "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+                    "x-middleware-response-cache-control": NO_STORE_CACHE_CONTROL,
                 },
             };
         }

package/dist/http/openNextResponse.js

@@ -1,5 +1,6 @@
 import { Transform } from "node:stream";
 import { debug } from "../adapters/logger";
+import { fixCacheControlForError } from "../utils/cacheHeaders";
 import { parseHeaders, parseSetCookieHeader } from "./util";
 const SET_COOKIE_HEADER = "set-cookie";
 const CANNOT_BE_USED = "This cannot be used in OpenNext";
@@ -327,16 +328,8 @@ export class OpenNextNodeResponse extends Transform {
     // For some reason, next returns the 500 error page with some cache-control headers
     // We need to fix that
     fixHeadersForError() {
-        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
-            return;
-        }
-        // We only check for 404 and 500 errors
-        // The rest should be errors that are handled by the user and they should set the cache headers themselves
-        if (this.statusCode === 404 || this.statusCode === 500) {
-            // For some reason calling this.setHeader("Cache-Control", "no-cache, no-store, must-revalidate") does not work here
-            // The function is not even called, i'm probably missing something obvious
-            this.headers["cache-control"] =
-                "private, no-cache, no-store, max-age=0, must-revalidate";
-        }
+        // NOTE: this assigns to `this.headers` directly rather than going through
+        // `this.setHeader()`, because for some reason `setHeader` is not even called from here.
+        fixCacheControlForError(this.headers, this.statusCode);
     }
 }

package/dist/overrides/queue/direct.js

@@ -1,3 +1,4 @@
+import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 const queue = {
     name: "dev-queue",
     send: async (message) => {
@@ -9,8 +10,8 @@ const queue = {
         await globalThis.internalFetch(`${protocol}://${host}${url}`, {
             method: "HEAD",
             headers: {
-                "x-prerender-revalidate": revalidateId,
-                "x-isr": "1",
+                [PRERENDER_REVALIDATE_HEADER]: revalidateId,
+                [ISR_HEADER]: "1",
             },
         });
     },

package/dist/utils/cache.js

@@ -1,4 +1,5 @@
 import { debug } from "../adapters/logger";
+import { CACHE_TAGS_HEADER } from "./cacheHeaders";
 import { compareSemver } from "./semver";
 /**
  *
@@ -90,8 +91,8 @@ export function getTagsFromValue(value) {
     }
     // The try catch is necessary for older version of next.js that may fail on this
     try {
-        const cacheTags = value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
-        delete value.meta?.headers?.["x-next-cache-tags"];
+        const cacheTags = value.meta?.headers?.[CACHE_TAGS_HEADER]?.split(",") ?? [];
+        delete value.meta?.headers?.[CACHE_TAGS_HEADER];
         return cacheTags;
     }
     catch (e) {

package/dist/utils/cacheHeaders.d.ts

@@ -0,0 +1,52 @@
+import type { OutgoingHttpHeaders } from "node:http";
+/**
+ * The name of the `cache-control` response header.
+ */
+export declare const CACHE_CONTROL_HEADER = "cache-control";
+/**
+ * The name of the header Next.js uses to report the cache status of a response.
+ */
+export declare const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
+/**
+ * The name of the header OpenNext uses to report the cache status of a response
+ * served by the cache interceptor.
+ */
+export declare const OPEN_NEXT_CACHE_HEADER = "x-opennext-cache";
+/**
+ * The name of the header Next.js uses to store the tags of a cache entry.
+ *
+ * Note that `types/cache.ts` repeats the literal, on purpose: it is a types only
+ * module and importing a value into it would give it a runtime dependency.
+ */
+export declare const CACHE_TAGS_HEADER = "x-next-cache-tags";
+/**
+ * The name of the header OpenNext uses to mark a request as an ISR revalidation.
+ */
+export declare const ISR_HEADER = "x-isr";
+/**
+ * The name of the header Next.js uses to authorize a revalidation request.
+ *
+ * Carries the preview mode id from the prerender manifest.
+ */
+export declare const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/**
+ * The `cache-control` OpenNext forces on error responses so that they are never cached.
+ */
+export declare const NO_STORE_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
+/**
+ * Overrides `cache-control` on error responses so that they are not cached.
+ *
+ * Next.js attaches cacheable `cache-control` headers to some error responses, and it writes
+ * `notFound()` results for ISR routes to the incremental cache. Without this the CDN would hold
+ * on to a 404 or a 500 - a transient one, such as a row that is not replicated yet, would stay
+ * at the edge for as long as the route's revalidate period, up to a year for an SSG route.
+ *
+ * Only 404 and 500 are overridden. Any other error status is assumed to be produced by the
+ * application, which is then responsible for setting its own cache headers.
+ *
+ * Set `OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS=true` to opt out and keep the original headers.
+ *
+ * @param headers The response headers, mutated in place
+ * @param statusCode The status code of the response
+ */
+export declare function fixCacheControlForError(headers: OutgoingHttpHeaders | Record<string, string | string[]>, statusCode: number): void;

package/dist/utils/cacheHeaders.js

@@ -0,0 +1,58 @@
+/**
+ * The name of the `cache-control` response header.
+ */
+export const CACHE_CONTROL_HEADER = "cache-control";
+/**
+ * The name of the header Next.js uses to report the cache status of a response.
+ */
+export const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
+/**
+ * The name of the header OpenNext uses to report the cache status of a response
+ * served by the cache interceptor.
+ */
+export const OPEN_NEXT_CACHE_HEADER = "x-opennext-cache";
+/**
+ * The name of the header Next.js uses to store the tags of a cache entry.
+ *
+ * Note that `types/cache.ts` repeats the literal, on purpose: it is a types only
+ * module and importing a value into it would give it a runtime dependency.
+ */
+export const CACHE_TAGS_HEADER = "x-next-cache-tags";
+/**
+ * The name of the header OpenNext uses to mark a request as an ISR revalidation.
+ */
+export const ISR_HEADER = "x-isr";
+/**
+ * The name of the header Next.js uses to authorize a revalidation request.
+ *
+ * Carries the preview mode id from the prerender manifest.
+ */
+export const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/**
+ * The `cache-control` OpenNext forces on error responses so that they are never cached.
+ */
+export const NO_STORE_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
+/**
+ * Overrides `cache-control` on error responses so that they are not cached.
+ *
+ * Next.js attaches cacheable `cache-control` headers to some error responses, and it writes
+ * `notFound()` results for ISR routes to the incremental cache. Without this the CDN would hold
+ * on to a 404 or a 500 - a transient one, such as a row that is not replicated yet, would stay
+ * at the edge for as long as the route's revalidate period, up to a year for an SSG route.
+ *
+ * Only 404 and 500 are overridden. Any other error status is assumed to be produced by the
+ * application, which is then responsible for setting its own cache headers.
+ *
+ * Set `OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS=true` to opt out and keep the original headers.
+ *
+ * @param headers The response headers, mutated in place
+ * @param statusCode The status code of the response
+ */
+export function fixCacheControlForError(headers, statusCode) {
+    if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
+        return;
+    }
+    if (statusCode === 404 || statusCode === 500) {
+        headers[CACHE_CONTROL_HEADER] = NO_STORE_CACHE_CONTROL;
+    }
+}

package/package.json

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