@opennextjs/aws 3.7.2 → 3.7.4

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/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,

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,20 @@ 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;
+        // We only set the status code if it is not a NaN and it is a number
+        // Only allow status codes between 100 and 599 https://httpwg.org/specs/rfc9110.html#status.codes
+        if (statusCode &&
+            Number.isInteger(statusCode) &&
+            statusCode >= 100 &&
+            statusCode <= 599) {
+            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/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.2",
+  "version": "3.7.4",
   "bin": {
     "open-next": "./dist/index.js"
   },