@opennextjs/aws 3.7.1 → 3.7.3

package/dist/adapters/cache.d.ts

@@ -1,4 +1,5 @@
 import type { CacheHandlerValue, IncrementalCacheContext, IncrementalCacheValue } from "../types/cache";
+export declare const SOFT_TAG_PREFIX = "_N_T_/";
 export default class Cache {
     get(key: string, options?: boolean | {
         fetchCache?: boolean;

package/dist/adapters/cache.js

@@ -1,6 +1,7 @@
 import { getTagsFromValue, hasBeenRevalidated, writeTags } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
+export const SOFT_TAG_PREFIX = "_N_T_/";
 function isFetchCache(options) {
     if (typeof options === "boolean") {
         return options;
@@ -34,18 +35,22 @@ export default class Cache {
                 return null;
             const _tags = [...(tags ?? []), ...(softTags ?? [])];
             const _lastModified = cachedEntry.lastModified ?? Date.now();
-            const _hasBeenRevalidated = await hasBeenRevalidated(key, _tags, cachedEntry);
+            const _hasBeenRevalidated = cachedEntry.shouldBypassTagCache
+                ? false
+                : await hasBeenRevalidated(key, _tags, cachedEntry);
             if (_hasBeenRevalidated)
                 return null;
             // For cases where we don't have tags, we need to ensure that the soft tags are not being revalidated
             // We only need to check for the path as it should already contain all the tags
             if ((tags ?? []).length === 0) {
                 // Then we need to find the path for the given key
-                const path = softTags?.find((tag) => tag.startsWith("_N_T_/") &&
+                const path = softTags?.find((tag) => tag.startsWith(SOFT_TAG_PREFIX) &&
                     !tag.endsWith("layout") &&
                     !tag.endsWith("page"));
                 if (path) {
-                    const hasPathBeenUpdated = await hasBeenRevalidated(path.replace("_N_T_/", ""), [], cachedEntry);
+                    const hasPathBeenUpdated = cachedEntry.shouldBypassTagCache
+                        ? false
+                        : await hasBeenRevalidated(path.replace(SOFT_TAG_PREFIX, ""), [], cachedEntry);
                     if (hasPathBeenUpdated) {
                         // In case the path has been revalidated, we don't want to use the fetch cache
                         return null;
@@ -73,7 +78,9 @@ export default class Cache {
             const meta = cacheData.meta;
             const tags = getTagsFromValue(cacheData);
             const _lastModified = cachedEntry.lastModified ?? Date.now();
-            const _hasBeenRevalidated = await hasBeenRevalidated(key, tags, cachedEntry);
+            const _hasBeenRevalidated = cachedEntry.shouldBypassTagCache
+                ? false
+                : await hasBeenRevalidated(key, tags, cachedEntry);
             if (_hasBeenRevalidated)
                 return null;
             const store = globalThis.__openNextAls.getStore();
@@ -274,11 +281,11 @@ export default class Cache {
                     tag,
                 }));
                 // If the tag is a soft tag, we should also revalidate the hard tags
-                if (tag.startsWith("_N_T_/")) {
+                if (tag.startsWith(SOFT_TAG_PREFIX)) {
                     for (const path of paths) {
                         // We need to find all hard tags for a given path
                         const _tags = await globalThis.tagCache.getByPath(path);
-                        const hardTags = _tags.filter((t) => !t.startsWith("_N_T_/"));
+                        const hardTags = _tags.filter((t) => !t.startsWith(SOFT_TAG_PREFIX));
                         // For every hard tag, we need to find all paths and revalidate them
                         for (const hardTag of hardTags) {
                             const _paths = await globalThis.tagCache.getByTag(hardTag);
@@ -296,7 +303,7 @@ export default class Cache {
                 // This only applies to `revalidateTag`, not to `res.revalidate()`
                 const uniquePaths = Array.from(new Set(toInsert
                     // We need to filter fetch cache key as they are not in the CDN
-                    .filter((t) => t.tag.startsWith("_N_T_/"))
+                    .filter((t) => t.tag.startsWith(SOFT_TAG_PREFIX))
                     .map((t) => `/${t.path}`)));
                 if (uniquePaths.length > 0) {
                     await globalThis.cdnInvalidationHandler.invalidatePaths(uniquePaths.map((path) => ({

package/dist/adapters/composable-cache.js

@@ -8,7 +8,13 @@ export default {
             // We first check if we have a pending write for this cache key
             // If we do, we return the pending promise instead of fetching the cache
             if (pendingWritePromiseMap.has(cacheKey)) {
-                return pendingWritePromiseMap.get(cacheKey);
+                const stored = pendingWritePromiseMap.get(cacheKey);
+                if (stored) {
+                    return stored.then((entry) => ({
+                        ...entry,
+                        value: toReadableStream(entry.value),
+                    }));
+                }
             }
             const result = await globalThis.incrementalCache.get(cacheKey, "composable");
             if (!result?.value?.value) {
@@ -18,13 +24,17 @@ export default {
             // We need to check if the tags associated with this entry has been revalidated
             if (globalThis.tagCache.mode === "nextMode" &&
                 result.value.tags.length > 0) {
-                const hasBeenRevalidated = await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
+                const hasBeenRevalidated = result.shouldBypassTagCache
+                    ? false
+                    : await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
                 if (hasBeenRevalidated)
                     return undefined;
             }
             else if (globalThis.tagCache.mode === "original" ||
                 globalThis.tagCache.mode === undefined) {
-                const hasBeenRevalidated = (await globalThis.tagCache.getLastModified(cacheKey, result.lastModified)) === -1;
+                const hasBeenRevalidated = result.shouldBypassTagCache
+                    ? false
+                    : (await globalThis.tagCache.getLastModified(cacheKey, result.lastModified)) === -1;
                 if (hasBeenRevalidated)
                     return undefined;
             }
@@ -39,14 +49,17 @@ export default {
         }
     },
     async set(cacheKey, pendingEntry) {
-        pendingWritePromiseMap.set(cacheKey, pendingEntry);
-        const entry = await pendingEntry.finally(() => {
+        const promiseEntry = pendingEntry.then(async (entry) => ({
+            ...entry,
+            value: await fromReadableStream(entry.value),
+        }));
+        pendingWritePromiseMap.set(cacheKey, promiseEntry);
+        const entry = await promiseEntry.finally(() => {
             pendingWritePromiseMap.delete(cacheKey);
         });
-        const valueToStore = await fromReadableStream(entry.value);
         await globalThis.incrementalCache.set(cacheKey, {
             ...entry,
-            value: valueToStore,
+            value: entry.value,
         }, "composable");
         if (globalThis.tagCache.mode === "original") {
             const storedTags = await globalThis.tagCache.getByPath(cacheKey);

package/dist/adapters/middleware.js

@@ -3,7 +3,7 @@ import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveAssetResolver, resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
 import { constructNextUrl } from "../core/routing/util";
-import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_REWRITE_STATUS_CODE, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
@@ -39,6 +39,7 @@ const defaultHandler = async (internalEvent, options) => {
                             [INTERNAL_HEADER_INITIAL_URL]: internalEvent.url,
                             [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes),
                             [INTERNAL_EVENT_REQUEST_ID]: requestId,
+                            [INTERNAL_HEADER_REWRITE_STATUS_CODE]: String(result.rewriteStatusCode),
                         },
                     },
                     isExternalRewrite: result.isExternalRewrite,

package/dist/build/generateOutput.js

@@ -74,7 +74,7 @@ export async function generateOutput(options) {
     Object.entries(config.functions ?? {}).forEach(async ([key, value]) => {
         if (value.placement === "global") {
             edgeFunctions[key] = {
-                bundle: `.open-next/functions/${key}`,
+                bundle: `.open-next/server-functions/${key}`,
                 handler: indexHandler,
                 ...(await extractOverrideFn(value.override)),
             };

package/dist/build/installDeps.js

@@ -35,6 +35,28 @@ export function installDependencies(outputDir, installOptions) {
         });
         // Copy the node_modules to the outputDir
         fs.cpSync(path.join(tempInstallDir, "node_modules"), path.join(outputDir, "node_modules"), { recursive: true, force: true, dereference: true });
+        // This is a workaround for Node `22.17.0` and `22.17.1`
+        // https://github.com/nodejs/node/issues/59168
+        const nodeVersion = process.version;
+        if (nodeVersion === "v22.17.0" || nodeVersion === "v22.17.1") {
+            const tempBinDir = path.join(tempInstallDir, "node_modules", ".bin");
+            const outputBinDir = path.join(outputDir, "node_modules", ".bin");
+            for (const fileName of fs.readdirSync(tempBinDir)) {
+                const symlinkPath = path.join(tempBinDir, fileName);
+                const stat = fs.lstatSync(symlinkPath);
+                if (stat.isSymbolicLink()) {
+                    const linkTarget = fs.readlinkSync(symlinkPath);
+                    const realFilePath = path.resolve(tempBinDir, linkTarget);
+                    const outputFilePath = path.join(outputBinDir, fileName);
+                    if (fs.existsSync(outputFilePath)) {
+                        fs.unlinkSync(outputFilePath);
+                    }
+                    fs.copyFileSync(realFilePath, outputFilePath);
+                    fs.chmodSync(outputFilePath, "755");
+                    logger.debug(`Replaced symlink ${fileName} with actual file`);
+                }
+            }
+        }
         // Cleanup tempDir
         fs.rmSync(tempInstallDir, { recursive: true, force: true });
         logger.info(`Dependencies installed for ${name}`);

package/dist/build/patch/codePatcher.d.ts

@@ -1,15 +1,14 @@
 import type { getManifests } from "../copyTracedFiles.js";
 import * as buildHelper from "../helper.js";
-type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
-export interface VersionedField<T> {
-    /**
-     * The versions of Next.js that this field should be used for
-     * Should be in the format `">=16.0.0 <=17.0.0"` or `">=16.0.0"` or `"<=17.0.0"`
-     * **Be careful with spaces**
-     */
-    versions?: Versions;
-    field: T;
-}
+/**
+ * Accepted formats:
+ * - `">=16.0.0"`
+ * - `"<=16.0.0"`
+ * - `">=16.0.0 <=17.0.0"`
+ *
+ * **Be careful with spaces**
+ */
+export type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
 export type PatchCodeFn = (args: {
     /**
      * The code of the file that needs to be patched
@@ -32,15 +31,23 @@ interface IndividualPatch {
     pathFilter: RegExp;
     contentFilter?: RegExp;
     patchCode: PatchCodeFn;
+    versions?: Versions;
 }
 export interface CodePatcher {
     name: string;
-    patches: IndividualPatch | VersionedField<IndividualPatch>[];
+    patches: IndividualPatch[];
 }
 export declare function parseVersions(versions?: Versions): {
     before?: string;
     after?: string;
 };
-export declare function extractVersionedField<T>(fields: VersionedField<T>[], version: string): T[];
+/**
+ * Check whether the version is in the range
+ *
+ * @param version A semver version
+ * @param versionRange A version range
+ * @returns whether the version satisfies the range
+ */
+export declare function isVersionInRange(version: string, versionRange?: Versions): boolean;
 export declare function applyCodePatches(buildOptions: buildHelper.BuildOptions, tracedFiles: string[], manifests: ReturnType<typeof getManifests>, codePatcher: CodePatcher[]): Promise<void>;
 export {};

package/dist/build/patch/codePatcher.js

@@ -39,50 +39,33 @@ export function parseVersions(versions) {
         after,
     };
 }
-export function extractVersionedField(fields, version) {
-    const result = [];
-    for (const field of fields) {
-        // No versions specified, the patch always apply
-        if (!field.versions) {
-            result.push(field.field);
-            continue;
-        }
-        const { before, after } = parseVersions(field.versions);
-        // range
-        if (before && after) {
-            if (buildHelper.compareSemver(version, "<=", before) &&
-                buildHelper.compareSemver(version, ">=", after)) {
-                result.push(field.field);
-            }
-            continue;
-        }
-        // before only
-        if (before) {
-            if (buildHelper.compareSemver(version, "<=", before)) {
-                result.push(field.field);
-            }
-            continue;
-        }
-        // after only
-        if (after) {
-            if (buildHelper.compareSemver(version, ">=", after)) {
-                result.push(field.field);
-            }
-        }
+/**
+ * Check whether the version is in the range
+ *
+ * @param version A semver version
+ * @param versionRange A version range
+ * @returns whether the version satisfies the range
+ */
+export function isVersionInRange(version, versionRange) {
+    const { before, after } = parseVersions(versionRange);
+    let inRange = true;
+    if (before) {
+        inRange &&= buildHelper.compareSemver(version, "<=", before);
+    }
+    if (after) {
+        inRange &&= buildHelper.compareSemver(version, ">=", after);
     }
-    return result;
+    return inRange;
 }
 export async function applyCodePatches(buildOptions, tracedFiles, manifests, codePatcher) {
-    const nextVersion = buildOptions.nextVersion;
     logger.time("Applying code patches");
     // We first filter against the version
     // We also flatten the array of patches so that we get both the name and all the necessary patches
-    const patchesToApply = codePatcher.flatMap(({ name, patches }) => Array.isArray(patches)
-        ? extractVersionedField(patches, nextVersion).map((patch) => ({
-            name,
-            patch,
-        }))
-        : [{ name, patch: patches }]);
+    const patchesToApply = codePatcher.flatMap(({ name, patches }) => {
+        return patches
+            .filter(({ versions }) => isVersionInRange(buildOptions.nextVersion, versions))
+            .map((patch) => ({ patch, name }));
+    });
     await Promise.all(tracedFiles.map(async (filePath) => {
         // We check the filename against the filter to see if we should apply the patch
         const patchMatchingPath = patchesToApply.filter(({ patch }) => {

package/dist/build/patch/patches/patchBackgroundRevalidation.d.ts

@@ -3,9 +3,7 @@ export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {
         versions: ">=14.1.0";
-        field: {
-            pathFilter: RegExp;
-            patchCode: import("../codePatcher.js").PatchCodeFn;
-        };
+        pathFilter: RegExp;
+        patchCode: import("../codePatcher.js").PatchCodeFn;
     }[];
 };

package/dist/build/patch/patches/patchBackgroundRevalidation.js

@@ -18,10 +18,8 @@ export const patchBackgroundRevalidation = {
         {
             // TODO: test for earlier versions of Next
             versions: ">=14.1.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
-                patchCode: createPatchCode(rule),
-            },
+            pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+            patchCode: createPatchCode(rule),
         },
     ],
 };

package/dist/build/patch/patches/patchEnvVar.js

@@ -24,29 +24,23 @@ export const patchEnvVars = {
         // This patch will set the `NEXT_RUNTIME` env var to "node" to avoid loading unnecessary edge deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /module\.compiled\.js$/,
-                contentFilter: /process\.env\.NEXT_RUNTIME/,
-                patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
-            },
+            pathFilter: /module\.compiled\.js$/,
+            contentFilter: /process\.env\.NEXT_RUNTIME/,
+            patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
         },
         // This patch will set `NODE_ENV` to production to avoid loading unnecessary dev deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
-                contentFilter: /process\.env\.NODE_ENV/,
-                patchCode: createPatchCode(envVarRuleCreator("NODE_ENV", '"production"')),
-            },
+            pathFilter: /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
+            contentFilter: /process\.env\.NODE_ENV/,
+            patchCode: createPatchCode(envVarRuleCreator("NODE_ENV", '"production"')),
         },
         // This patch will set `TURBOPACK` env to false to avoid loading turbopack related deps at runtime
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: /module\.compiled\.js$/,
-                contentFilter: /process\.env\.TURBOPACK/,
-                patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
-            },
+            pathFilter: /module\.compiled\.js$/,
+            contentFilter: /process\.env\.TURBOPACK/,
+            patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
         },
     ],
 };

package/dist/build/patch/patches/patchFetchCacheISR.d.ts

@@ -1,7 +1,7 @@
 import type { CodePatcher } from "../codePatcher.js";
-export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
-export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
-export declare const useCacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: binary_expression\n    has: \n      kind: member_expression\n      pattern: $STORE_OR_CACHE.isDraftMode\n    inside:\n      kind: if_statement\n      stopBy: end\n      has: \n        kind: return_statement\n        any:\n          - has:\n              kind: 'true'\n          - has:\n              regex: '!0'\n        stopBy: end\nfix:\n  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'";
+export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has:\n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has:\n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const useCacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: binary_expression\n    has:\n      kind: member_expression\n      pattern: $STORE_OR_CACHE.isDraftMode\n    inside:\n      kind: if_statement\n      stopBy: end\n      has:\n        kind: return_statement\n        any:\n          - has:\n              kind: 'true'\n          - has:\n              regex: '!0'\n        stopBy: end\nfix:\n  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'";
 export declare const patchFetchCacheForISR: CodePatcher;
 export declare const patchUnstableCacheForISR: CodePatcher;
 export declare const patchUseCacheForISR: CodePatcher;

package/dist/build/patch/patches/patchFetchCacheISR.js

@@ -9,7 +9,7 @@ rule:
     kind: ternary_expression
     all:
       - has: {kind: 'null'}
-      - has: 
+      - has:
           kind: await_expression
           has:
             kind: call_expression
@@ -48,7 +48,7 @@ rule:
       kind: statement_block
       has:
         kind: variable_declarator
-        has: 
+        has:
           kind: await_expression
           has:
             kind: call_expression
@@ -80,13 +80,13 @@ rule:
   pattern: $STORE_OR_CACHE.isOnDemandRevalidate
   inside:
     kind: binary_expression
-    has: 
+    has:
       kind: member_expression
       pattern: $STORE_OR_CACHE.isDraftMode
     inside:
       kind: if_statement
       stopBy: end
-      has: 
+      has:
         kind: return_statement
         any:
           - has:
@@ -101,11 +101,9 @@ export const patchFetchCacheForISR = {
     patches: [
         {
             versions: ">=14.0.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(fetchRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(fetchRule, Lang.JavaScript),
         },
     ],
 };
@@ -114,11 +112,9 @@ export const patchUnstableCacheForISR = {
     patches: [
         {
             versions: ">=14.2.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
         },
     ],
 };
@@ -127,11 +123,9 @@ export const patchUseCacheForISR = {
     patches: [
         {
             versions: ">=15.3.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|\.runtime\..*\.js|use-cache/use-cache-wrapper\.js)$`, { escape: false }),
-                contentFilter: /\.isOnDemandRevalidate/,
-                patchCode: createPatchCode(useCacheRule, Lang.JavaScript),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|\.runtime\..*\.js|use-cache/use-cache-wrapper\.js)$`, { escape: false }),
+            contentFilter: /\.isOnDemandRevalidate/,
+            patchCode: createPatchCode(useCacheRule, Lang.JavaScript),
         },
     ],
 };

package/dist/build/patch/patches/patchFetchCacheWaitUntil.js

@@ -26,11 +26,9 @@ export const patchFetchCacheSetMissingWaitUntil = {
     patches: [
         {
             versions: ">=15.0.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
-                contentFilter: /arrayBuffer\(\)\s*\.then/,
-                patchCode: createPatchCode(rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+            contentFilter: /arrayBuffer\(\)\s*\.then/,
+            patchCode: createPatchCode(rule),
         },
     ],
 };

package/dist/build/patch/patches/patchNextServer.js

@@ -71,27 +71,21 @@ const pathFilter = getCrossPlatformPathRegex(String.raw `/next/dist/server/next-
 const babelPatches = [
     // Empty the body of `NextServer#runMiddleware`
     {
-        field: {
-            pathFilter,
-            contentFilter: /runMiddleware\(/,
-            patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
-        },
+        pathFilter,
+        contentFilter: /runMiddleware\(/,
+        patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
     },
     // Empty the body of `NextServer#runEdgeFunction`
     {
-        field: {
-            pathFilter,
-            contentFilter: /runEdgeFunction\(/,
-            patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
-        },
+        pathFilter,
+        contentFilter: /runEdgeFunction\(/,
+        patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
     },
     // Drop `error-inspect` that pulls babel
     {
-        field: {
-            pathFilter,
-            contentFilter: /error-inspect/,
-            patchCode: createPatchCode(errorInspectRule),
-        },
+        pathFilter,
+        contentFilter: /error-inspect/,
+        patchCode: createPatchCode(errorInspectRule),
     },
 ];
 export const patchNextServer = {
@@ -99,30 +93,24 @@ export const patchNextServer = {
     patches: [
         // Empty the body of `NextServer#imageOptimizer` - unused in OpenNext
         {
-            field: {
-                pathFilter,
-                contentFilter: /imageOptimizer\(/,
-                patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
-            },
+            pathFilter,
+            contentFilter: /imageOptimizer\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
         },
         // Disable Next background preloading done at creation of `NextServer`
         {
             versions: ">=14.0.0",
-            field: {
-                pathFilter,
-                contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
-                patchCode: createPatchCode(disablePreloadingRule),
-            },
+            pathFilter,
+            contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
+            patchCode: createPatchCode(disablePreloadingRule),
         },
         // Don't match edge functions in `NextServer`
         {
             // Next 12 and some version of 13 use the bundled middleware/edge function
             versions: ">=14.0.0",
-            field: {
-                pathFilter,
-                contentFilter: /getMiddlewareManifest/,
-                patchCode: createPatchCode(removeMiddlewareManifestRule),
-            },
+            pathFilter,
+            contentFilter: /getMiddlewareManifest/,
+            patchCode: createPatchCode(removeMiddlewareManifestRule),
         },
         ...babelPatches,
     ],

package/dist/core/requestHandler.js

@@ -5,7 +5,7 @@ import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { constructNextUrl, convertRes, convertToQuery, convertToQueryString, createServerResponse, } from "./routing/util";
-import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_REWRITE_STATUS_CODE, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
@@ -37,6 +37,7 @@ export async function openNextHandler(internalEvent, options) {
             resolvedRoutes: initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES]
                 ? JSON.parse(initialHeaders[INTERNAL_HEADER_RESOLVED_ROUTES])
                 : [],
+            rewriteStatusCode: Number.parseInt(initialHeaders[INTERNAL_HEADER_REWRITE_STATUS_CODE]),
         };
         let routingResult = {
             internalEvent,
@@ -263,6 +264,7 @@ async function tryRenderError(type, res, internalEvent) {
     }
     catch (e) {
         error("NextJS request failed.", e);
+        res.statusCode = 500;
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify({
             message: "Server failed to respond.",

package/dist/core/routing/cacheInterceptor.js

@@ -144,6 +144,14 @@ export async function cacheInterceptor(event) {
     if (Boolean(event.headers["next-action"]) ||
         Boolean(event.headers["x-prerender-revalidate"]))
         return event;
+    // Check for Next.js preview mode cookies
+    const cookies = event.headers.cookie || "";
+    const hasPreviewData = cookies.includes("__prerender_bypass") ||
+        cookies.includes("__next_preview_data");
+    if (hasPreviewData) {
+        debug("Preview mode detected, passing through to handler");
+        return event;
+    }
     // We localize the path in case i18n is enabled
     let localizedPath = localizePath(event);
     // If using basePath we need to remove it from the path

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

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

package/dist/core/routing/middleware.js

@@ -2,10 +2,11 @@ import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManif
 import { emptyReadableStream } from "../../utils/stream.js";
 import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
 import { localizePath } from "./i18n/index.js";
-import { convertBodyToReadableStream, getMiddlewareMatch, isExternal, } from "./util.js";
+import { convertBodyToReadableStream, getMiddlewareMatch, isExternal, normalizeLocationHeader, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
 const functionsConfigManifest = FunctionsConfigManifest;
 const middleMatch = getMiddlewareMatch(middlewareManifest, functionsConfigManifest);
+const REDIRECTS = new Set([301, 302, 303, 307, 308]);
 function defaultMiddlewareLoader() {
     // @ts-expect-error - This is bundled
     return import("./middleware.mjs");
@@ -94,6 +95,10 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
                     ? [...resHeaders[key], value]
                     : [value];
             }
+            else if (REDIRECTS.has(statusCode) &&
+                key.toLowerCase() === "location") {
+                resHeaders[key] = normalizeLocationHeader(value, internalEvent.url);
+            }
             else {
                 resHeaders[key] = value;
             }
@@ -146,5 +151,6 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         cookies: internalEvent.cookies,
         remoteAddress: internalEvent.remoteAddress,
         isExternalRewrite,
+        rewriteStatusCode: statusCode,
     };
 }

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

@@ -104,3 +104,16 @@ export declare function fixISRHeaders(headers: OutgoingHttpHeaders): void;
  */
 export declare function createServerResponse(routingResult: RoutingResult, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;
 export declare function invalidateCDNOnRequest(params: RoutingResult, headers: OutgoingHttpHeaders): Promise<void>;
+/**
+ * Normalizes the Location header to either be a relative path or a full URL.
+ * If the Location header is relative to the origin, it will return a relative path.
+ * If it is an absolute URL, it will return the full URL.
+ * Redirects from Next config query parameters are encoded using `stringifyQs`
+ * Redirects from the middleware the query parameters are not encoded.
+ *
+ * @param location The Location header value
+ * @param baseUrl The base URL to use for relative paths (i.e the original request URL)
+ * @param encodeQuery Optional flag to indicate if query parameters should be encoded in the Location header
+ * @returns An absolute or relative Location header value
+ */
+export declare function normalizeLocationHeader(location: string, baseUrl: string, encodeQuery?: boolean): string;

package/dist/core/routing/util.js

@@ -1,4 +1,5 @@
 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";
@@ -338,7 +339,7 @@ export function createServerResponse(routingResult, headers, responseStream) {
     }, async (_headers) => {
         await revalidateIfRequired(internalEvent.headers.host, internalEvent.rawPath, _headers);
         await invalidateCDNOnRequest(routingResult, _headers);
-    }, responseStream, headers);
+    }, responseStream, headers, routingResult.rewriteStatusCode);
 }
 // This function is used only for `res.revalidate()`
 export async function invalidateCDNOnRequest(params, headers) {
@@ -356,3 +357,35 @@ export async function invalidateCDNOnRequest(params, headers) {
         ]);
     }
 }
+/**
+ * Normalizes the Location header to either be a relative path or a full URL.
+ * If the Location header is relative to the origin, it will return a relative path.
+ * If it is an absolute URL, it will return the full URL.
+ * Redirects from Next config query parameters are encoded using `stringifyQs`
+ * Redirects from the middleware the query parameters are not encoded.
+ *
+ * @param location The Location header value
+ * @param baseUrl The base URL to use for relative paths (i.e the original request URL)
+ * @param encodeQuery Optional flag to indicate if query parameters should be encoded in the Location header
+ * @returns An absolute or relative Location header value
+ */
+export function normalizeLocationHeader(location, baseUrl, encodeQuery = false) {
+    if (!URL.canParse(location)) {
+        // If the location is not a valid URL, return it as-is
+        return location;
+    }
+    const locationURL = new URL(location);
+    const origin = new URL(baseUrl).origin;
+    let search = locationURL.search;
+    // If encodeQuery is true, we need to encode the query parameters
+    // We could have used URLSearchParams, but that doesn't match what Next does.
+    if (encodeQuery && search) {
+        search = `?${stringifyQs(parseQs(search.slice(1)))}`;
+    }
+    const href = `${locationURL.origin}${locationURL.pathname}${search}${locationURL.hash}`;
+    // The URL is relative if the origin is the same as the base URL's origin
+    if (locationURL.origin === origin) {
+        return href.slice(origin.length);
+    }
+    return href;
+}

package/dist/core/routingHandler.d.ts

@@ -6,6 +6,7 @@ export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
 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 declare const INTERNAL_HEADER_REWRITE_STATUS_CODE = "x-opennext-rewrite-status-code";
 export declare const INTERNAL_EVENT_REQUEST_ID = "x-opennext-request-id";
 export default function routingHandler(event: InternalEvent, { assetResolver }: {
     assetResolver?: AssetResolver;

package/dist/core/routingHandler.js

@@ -5,13 +5,14 @@ import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
 import { dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
-import { constructNextUrl } from "./routing/util";
+import { constructNextUrl, normalizeLocationHeader } 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_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`;
+export const INTERNAL_HEADER_REWRITE_STATUS_CODE = `${INTERNAL_HEADER_PREFIX}rewrite-status-code`;
 export const INTERNAL_EVENT_REQUEST_ID = `${INTERNAL_HEADER_PREFIX}request-id`;
 // Geolocation headers starting from Nextjs 15
 // See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
@@ -66,8 +67,7 @@ export default async function routingHandler(event, { assetResolver }) {
         const redirect = handleRedirects(eventOrResult, RoutesManifest.redirects);
         if (redirect) {
             // We need to encode the value in the Location header to make sure it is valid according to RFC
-            // https://stackoverflow.com/a/7654605/16587222
-            redirect.headers.Location = new URL(redirect.headers.Location).href;
+            redirect.headers.Location = normalizeLocationHeader(redirect.headers.Location, event.url, true);
             debug("redirect", redirect);
             return redirect;
         }
@@ -171,6 +171,7 @@ export default async function routingHandler(event, { assetResolver }) {
             locale: NextConfig.i18n
                 ? detectLocale(eventOrResult, NextConfig.i18n)
                 : undefined,
+            rewriteStatusCode: middlewareEventOrResult.rewriteStatusCode,
         };
     }
     catch (e) {

package/dist/http/openNextResponse.d.ts

@@ -34,7 +34,7 @@ export declare class OpenNextNodeResponse extends Transform implements ServerRes
     socket: Socket | null;
     setTimeout(_msecs: number, _callback?: (() => void) | undefined): this;
     addTrailers(_headers: OutgoingHttpHeaders | readonly [string, string][]): void;
-    constructor(fixHeaders: (headers: OutgoingHttpHeaders) => void, onEnd: (headers: OutgoingHttpHeaders) => Promise<void>, streamCreator?: StreamCreator | undefined, initialHeaders?: OutgoingHttpHeaders | undefined);
+    constructor(fixHeaders: (headers: OutgoingHttpHeaders) => void, onEnd: (headers: OutgoingHttpHeaders) => Promise<void>, streamCreator?: StreamCreator | undefined, initialHeaders?: OutgoingHttpHeaders | undefined, statusCode?: number);
     get originalResponse(): this;
     get finished(): boolean;
     setHeader(name: string, value: string | string[]): this;

package/dist/http/openNextResponse.js

@@ -51,12 +51,15 @@ export class OpenNextNodeResponse extends Transform {
     addTrailers(_headers) {
         throw new Error(CANNOT_BE_USED);
     }
-    constructor(fixHeaders, onEnd, streamCreator, initialHeaders) {
+    constructor(fixHeaders, onEnd, streamCreator, initialHeaders, statusCode) {
         super();
         this.fixHeaders = fixHeaders;
         this.onEnd = onEnd;
         this.streamCreator = streamCreator;
         this.initialHeaders = initialHeaders;
+        if (statusCode !== undefined) {
+            this.statusCode = statusCode;
+        }
     }
     // Necessary for next 12
     // We might have to implement all the methods here

package/dist/overrides/wrappers/express-dev.js

@@ -20,6 +20,12 @@ const wrapper = async (handler, converter) => {
         await imageHandler(internalEvent, { streamCreator });
     });
     app.all("*paths", async (req, res) => {
+        if (req.protocol === "http" && req.hostname === "localhost") {
+            // This is used internally by Next.js during redirects in server actions. We need to set it to the origin of the request.
+            process.env.__NEXT_PRIVATE_ORIGIN = `${req.protocol}://${req.hostname}`;
+            // This is to make `next-auth` and other libraries that rely on this header to work locally out of the box.
+            req.headers["x-forwarded-proto"] = req.protocol;
+        }
         const internalEvent = await converter.convertFrom(req);
         const streamCreator = {
             writeHeaders: (prelude) => {

package/dist/plugins/content-updater.d.ts

@@ -5,7 +5,7 @@
  */
 import type { OnLoadOptions, Plugin, PluginBuild } from "esbuild";
 import type { BuildOptions } from "../build/helper";
-import { type VersionedField } from "../build/patch/codePatcher.js";
+import { type Versions } from "../build/patch/codePatcher.js";
 export type * from "esbuild";
 /**
  * The callbacks returns either an updated content or undefined if the content is unchanged.
@@ -23,6 +23,7 @@ export type OnUpdateOptions = OnLoadOptions & {
 };
 export type Updater = OnUpdateOptions & {
     callback: Callback;
+    versions?: Versions;
 };
 export declare class ContentUpdater {
     private buildOptions;
@@ -34,10 +35,10 @@ export declare class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @param updaters A list of code updaters
      * @returns A noop ESBuild plugin.
      */
-    updateContent(name: string, versionedUpdaters: VersionedField<Updater>[]): Plugin;
+    updateContent(name: string, updaters: Updater[]): Plugin;
     /**
      * Returns an ESBuild plugin applying the registered updates.
      */

package/dist/plugins/content-updater.js

@@ -4,7 +4,7 @@
  * The updater allows multiple plugins to update the content.
  */
 import { readFile } from "node:fs/promises";
-import { extractVersionedField, } from "../build/patch/codePatcher.js";
+import { isVersionInRange } from "../build/patch/codePatcher.js";
 export class ContentUpdater {
     buildOptions;
     updaters = new Map();
@@ -17,15 +17,14 @@ export class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @param updaters A list of code updaters
      * @returns A noop ESBuild plugin.
      */
-    updateContent(name, versionedUpdaters) {
+    updateContent(name, updaters) {
         if (this.updaters.has(name)) {
             throw new Error(`Plugin "${name}" already registered`);
         }
-        const updaters = extractVersionedField(versionedUpdaters, this.buildOptions.nextVersion);
-        this.updaters.set(name, updaters);
+        this.updaters.set(name, updaters.filter(({ versions }) => isVersionInRange(this.buildOptions.nextVersion, versions)));
         return {
             name,
             setup() { },

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

@@ -20,6 +20,7 @@ export type InternalResult = {
     headers: Record<string, string | string[]>;
     body: ReadableStream;
     isBase64Encoded: boolean;
+    rewriteStatusCode?: number;
 } & BaseEventOrResult<"core">;
 export interface StreamCreator {
     writeHeaders(prelude: {
@@ -92,6 +93,7 @@ export interface RoutingResult {
     initialURL: string;
     locale?: string;
     resolvedRoutes: ResolvedRoute[];
+    rewriteStatusCode?: number;
 }
 export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"middleware"> {
 }

package/dist/types/overrides.d.ts

@@ -63,6 +63,11 @@ export type CachedFetchValue = {
 export type WithLastModified<T> = {
     lastModified?: number;
     value?: T;
+    /**
+     * If set to true, we will not check the tag cache for this entry.
+     * `revalidateTag` and `revalidatePath` may not work as expected.
+     */
+    shouldBypassTagCache?: boolean;
 };
 export type CacheEntryType = Extension;
 export type CacheValue<CacheType extends CacheEntryType> = (CacheType extends "fetch" ? CachedFetchValue : CacheType extends "cache" ? CachedFile : StoredComposableCacheEntry) & {

package/package.json

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