@opennextjs/aws 4.0.2 → 4.1.0

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

@@ -5,46 +5,62 @@ import { debug } from "../../logger.js";
 //#override optimizeImage
 export async function optimizeImage(headers, imageParams, nextConfig, handleRequest) {
     const { isAbsolute, href } = imageParams;
-    // Signature for the fetch Image functions have changed across Next.js versions.
-    const isV15After15510 = compareSemver(globalThis.nextVersion, ">=", "15.5.10") &&
-        compareSemver(globalThis.nextVersion, "<", "16");
-    const isV15After15515 = compareSemver(globalThis.nextVersion, ">=", "15.5.16") &&
-        compareSemver(globalThis.nextVersion, "<", "16");
-    const isV16Plus = compareSemver(globalThis.nextVersion, ">=", "16");
-    const isAfter1615 = compareSemver(globalThis.nextVersion, ">=", "16.1.5");
-    const isAfter1625 = compareSemver(globalThis.nextVersion, ">=", "16.2.5");
-    // fetchInternalImage signature varies across Next.js versions:
-    //   <=v15.5.15, v16.0.0–v16.2.4: fetchInternalImage(href, req, res, handleRequest)
-    //   v15.5.16–v15.x, v16.2.5+:    fetchInternalImage(href, req, res, maximumResponseBody, handleRequest)
-    const isNewArgsForInternalFetch = isAfter1625 || isV15After15515;
-    // fetchExternalImage signature varies across Next.js versions:
-    //   <=v15.5.9:       fetchExternalImage(href)
-    //   v15.5.10–v15.x:  fetchExternalImage(href, maximumResponseBody)
-    //   v16.0.0–v16.1.4: fetchExternalImage(href, dangerouslyAllowLocalIP)
-    //   v16.1.5+:        fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody)
     // The default value for maximumResponseBody is 50KB in Next code
     // https://github.com/vercel/next.js/blob/0f38c522/packages/next/src/shared/lib/image-config.ts#L164
     const maximumResponseBody = nextConfig.images?.maximumResponseBody || 50_000_000;
-    const imageUpstream = isAbsolute
-        ? // https://github.com/vercel/next.js/blob/bfe2ab4/packages/next/src/server/image-optimizer.ts#L711
-            await (isAfter1615
-                ? fetchExternalImage(href, false, maximumResponseBody)
-                : isV16Plus
-                    ? // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
-                        fetchExternalImage(href, false)
-                    : isV15After15510
-                        ? // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
-                            fetchExternalImage(href, maximumResponseBody)
-                        : // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
-                            fetchExternalImage(href))
-        : await (isNewArgsForInternalFetch
-            ? fetchInternalImage(href, 
+    /**
+     * fetchExternalImage signature varies across Next.js versions:
+     *   <=v15.5.9:       fetchExternalImage(href)
+     *   v15.5.10–v15.x:  fetchExternalImage(href, maximumResponseBody)
+     *   v16.0.0–v16.1.4: fetchExternalImage(href, dangerouslyAllowLocalIP)
+     *   v16.1.5+:        fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody)
+     *
+     * https://github.com/vercel/next.js/blob/bfe2ab4/packages/next/src/server/image-optimizer.ts#L711
+     */
+    const callFetchExternalImage = () => {
+        const version = globalThis.nextVersion;
+        // v16.1.5+
+        if (compareSemver(version, ">=", "16.1.5")) {
+            return fetchExternalImage(href, false, 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);
+        }
+        // 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);
+        }
+        // <=v15.5.9
+        // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
+        return fetchExternalImage(href);
+    };
+    /**
+     * fetchInternalImage signature varies across Next.js versions:
+     *   <=v15.5.15, v16.0.0–v16.2.4: fetchInternalImage(href, req, res, handleRequest)
+     *   v15.5.16–v15.x, v16.2.5+:    fetchInternalImage(href, req, res, maximumResponseBody, handleRequest)
+     */
+    const callFetchInternalImage = () => {
+        const version = globalThis.nextVersion;
+        const isV15WithNewArgs = compareSemver(version, ">=", "15.5.16") &&
+            compareSemver(version, "<", "16");
+        // v15.5.16–v15.x, v16.2.5+
+        if (isV15WithNewArgs || compareSemver(version, ">=", "16.2.5")) {
+            return fetchInternalImage(href, 
             // @ts-expect-error - It is supposed to be an IncomingMessage object, but only the headers are used.
             { headers }, {}, // res object is not necessary as it's not actually used.
-            maximumResponseBody, handleRequest)
-            : // @ts-expect-error - fetchInternalImage signature has changed in Next.js 15.5.16 and 16.2.5
-                fetchInternalImage(href, { headers }, {}, // res object is not necessary as it's not actually used.
-                handleRequest));
+            maximumResponseBody, handleRequest);
+        }
+        // <=v15.5.15, v16.0.0–v16.2.4
+        // @ts-expect-error - fetchInternalImage signature has changed in Next.js 15.5.16 and 16.2.5
+        return fetchInternalImage(href, { headers }, {}, // res object is not necessary as it's not actually used.
+        handleRequest);
+    };
+    const imageUpstream = isAbsolute
+        ? await callFetchExternalImage()
+        : await callFetchInternalImage();
     const result = await imageOptimizer(imageUpstream, imageParams, 
     // @ts-ignore
     nextConfig, false);

package/dist/build/generateOutput.js

@@ -8,7 +8,8 @@ async function canStream(opts) {
         return false;
     }
     if (typeof opts.override.wrapper === "string") {
-        return opts.override.wrapper === "aws-lambda-streaming";
+        return (opts.override.wrapper === "aws-lambda-streaming" ||
+            opts.override.wrapper === "aws-apigw-streaming");
     }
     const wrapper = await opts.override.wrapper();
     return wrapper.supportStreaming;

package/dist/build/validateConfig.js

@@ -8,6 +8,7 @@ const compatibilityMatrix = {
     ],
     "aws-lambda-compressed": ["aws-apigw-v2"],
     "aws-lambda-streaming": ["aws-apigw-v2"],
+    "aws-apigw-streaming": ["aws-apigw-v1", "aws-apigw-v2"],
     cloudflare: ["edge"],
     "cloudflare-edge": ["edge"],
     "cloudflare-node": ["edge"],

package/dist/core/edgeFunctionHandler.js

@@ -2,7 +2,22 @@
 export default async function edgeFunctionHandler(request) {
     const path = new URL(request.url).pathname;
     const routes = globalThis._ROUTES;
-    const correspondingRoute = routes.find((route) => route.regex.some((r) => new RegExp(r).test(path)));
+    let decodedPath;
+    try {
+        // Decode the complete pathname atomically so a malformed escape cannot be
+        // partially decoded.
+        decodedPath = decodeURIComponent(path);
+    }
+    catch {
+        // A malformed pathname cannot provide a decoded route to match.
+    }
+    // Also match against the decoded pathname, while keeping the encoded URL in
+    // the request passed to middleware.
+    const correspondingRoute = routes.find((route) => route.regex.some((r) => {
+        const regex = new RegExp(r);
+        return (regex.test(path) ||
+            (decodedPath !== undefined && regex.test(decodedPath)));
+    }));
     if (!correspondingRoute) {
         throw new Error(`No route found for ${request.url}`);
     }

package/dist/core/routing/cacheInterceptor.js

@@ -169,19 +169,13 @@ function escapePathDelimiters(segment, escapeEncoded) {
  *
  * SSG cache key needs to be decoded, but some characters needs to be properly escaped
  * https://github.com/vercel/next.js/blob/34039551d2e5f611c0abde31a197d9985918adaf/packages/next/src/server/lib/router-utils/decode-path-params.ts#L11-L26
+ * Decoding must be atomic, as in Next.js. Partially decoding a malformed path
+ * could select a different cache route than the one evaluated by middleware.
  */
 function decodePathParams(pathname) {
     return pathname
         .split("/")
-        .map((segment) => {
-        try {
-            return escapePathDelimiters(decodeURIComponent(segment), true);
-        }
-        catch (e) {
-            // If decodeURIComponent fails, we return the original segment
-            return segment;
-        }
-    })
+        .map((segment) => escapePathDelimiters(decodeURIComponent(segment), true))
         .join("/");
 }
 export async function cacheInterceptor(event) {
@@ -205,14 +199,24 @@ export async function cacheInterceptor(event) {
     // We also need to remove trailing slash
     localizedPath = localizedPath.replace(/\/$/, "");
     // Then we decode the path params
-    localizedPath = decodePathParams(localizedPath);
+    try {
+        localizedPath = decodePathParams(localizedPath) || "/";
+    }
+    catch {
+        // Next.js rejects malformed path params. Do not let cache interception
+        // partially decode the path and select a different route identity.
+        return event;
+    }
+    // The route is keyed as `/` in the prerender manifest, but the generated
+    // cache asset for the app index route is uploaded as `/index`.
+    const cacheKey = localizedPath === "/" ? "/index" : localizedPath;
     debug("Checking cache for", localizedPath, PrerenderManifest);
-    const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath ?? "/") ||
+    const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath) ||
         Object.values(PrerenderManifest?.dynamicRoutes ?? {}).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
     debug("isISR", isISR);
     if (isISR) {
         try {
-            const cachedData = await globalThis.incrementalCache.get(localizedPath ?? "/index");
+            const cachedData = await globalThis.incrementalCache.get(cacheKey);
             debug("cached data in interceptor", cachedData);
             if (!cachedData?.value) {
                 return event;
@@ -223,7 +227,7 @@ export async function cacheInterceptor(event) {
                 cachedData.value?.type === "route") {
                 const _hasBeenRevalidated = cachedData.shouldBypassTagCache
                     ? false
-                    : await hasBeenRevalidated(localizedPath, tags, cachedData);
+                    : await hasBeenRevalidated(cacheKey, tags, cachedData);
                 if (_hasBeenRevalidated) {
                     return event;
                 }
@@ -231,7 +235,7 @@ export async function cacheInterceptor(event) {
             // Check if the cache entry is stale (valid but needs background revalidation)
             const _isStale = cachedData.shouldBypassTagCache
                 ? false
-                : await isStale(localizedPath, tags, cachedData.lastModified ?? Date.now());
+                : await isStale(cacheKey, tags, cachedData.lastModified ?? Date.now());
             const host = event.headers.host;
             switch (cachedData?.value?.type) {
                 case "app":

package/dist/core/routing/matcher.js

@@ -287,6 +287,10 @@ export function fixDataPage(internalEvent, buildId) {
             ...internalEvent,
             rawPath: newPath,
             query,
+            headers: {
+                ...internalEvent.headers,
+                "x-nextjs-data": "1",
+            },
             url: new URL(`${newPath}${convertToQueryString(query)}`, internalEvent.url).href,
         };
     }

package/dist/core/routing/middleware.js

@@ -29,7 +29,17 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
     const normalizedPath = localizePath(internalEvent);
-    const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
+    let decodedPath;
+    try {
+        decodedPath = decodeURIComponent(normalizedPath);
+    }
+    catch {
+        // An invalid encoding cannot provide a decoded pathname to match.
+    }
+    // Next.js also tries the decoded pathname for matching, while preserving the
+    // encoded pathname in the request passed to middleware.
+    const hasMatch = middleMatch.some((r) => r.test(normalizedPath) ||
+        (decodedPath !== undefined && r.test(decodedPath)));
     if (!hasMatch)
         return internalEvent;
     const initialUrl = new URL(normalizedPath, internalEvent.url);

package/dist/overrides/wrappers/aws-apigw-streaming.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: true;
+};
+export default _default;

package/dist/overrides/wrappers/aws-apigw-streaming.js

@@ -0,0 +1,74 @@
+import { Readable } from "node:stream";
+import { debug } from "../../adapters/logger";
+function formatWarmerResponse(event) {
+    const result = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({ serverId, type: "warmer" });
+        }, event.delay);
+    });
+    return result;
+}
+/**
+ * Streaming wrapper for an API Gateway proxy integration in
+ * `ResponseTransferMode: STREAM`.
+ *
+ * Differs from `aws-lambda-streaming` (the Lambda **Function URL** wrapper) in
+ * two ways, both mandated by API Gateway response streaming
+ * (https://aws.amazon.com/blogs/compute/building-responsive-apis-with-amazon-api-gateway-response-streaming/):
+ *
+ *  1. It does NOT set the
+ *     `application/vnd.awslambda.http-integration-response` content type. That
+ *     marker is Function-URL-specific metadata; API Gateway forwards it onto
+ *     the wire, corrupting HTTP framing.
+ *  2. It does NOT compress the response. API Gateway streaming explicitly does
+ *     not support content encoding, so the body is always emitted as
+ *     `identity`. Compression, if desired, is handled by the CDN in front
+ *     (e.g. CloudFront).
+ *
+ * The response framing itself — a JSON metadata prelude followed by an
+ * 8-null-byte delimiter, then the payload — is identical to the Function URL
+ * format and is what API Gateway expects in STREAM mode.
+ */
+const handler = async (handler, converter) => awslambda.streamifyResponse(async (event, responseStream, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    if ("type" in event) {
+        const result = await formatWarmerResponse(event);
+        responseStream.end(Buffer.from(JSON.stringify(result)), "utf-8");
+        await globalThis.__next_route_preloader("warmerEvent");
+        return;
+    }
+    const internalEvent = await converter.convertFrom(event);
+    responseStream.on("error", (err) => {
+        debug(err);
+        responseStream.end();
+    });
+    const streamCreator = {
+        writeHeaders: (_prelude) => {
+            // No content-encoding header — API Gateway streaming does not
+            // support content encoding; the body is emitted as identity.
+            _prelude.headers["content-encoding"] = "identity";
+            const prelude = JSON.stringify(_prelude);
+            responseStream.write(prelude);
+            // 8-null-byte delimiter separating the JSON metadata prelude from
+            // the response payload. Same framing API Gateway STREAM expects.
+            responseStream.write(new Uint8Array(8));
+            return responseStream;
+        },
+    };
+    const response = await handler(internalEvent, { streamCreator });
+    const isUsingEdge = globalThis.isEdgeRuntime ?? false;
+    if (isUsingEdge) {
+        debug("Headers has not been set, we must be in the edge runtime");
+        const stream = streamCreator.writeHeaders({
+            statusCode: response.statusCode,
+            headers: response.headers,
+            cookies: [],
+        });
+        Readable.fromWeb(response.body).pipe(stream);
+    }
+});
+export default {
+    wrapper: handler,
+    name: "aws-apigw-streaming",
+    supportStreaming: true,
+};

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

@@ -96,7 +96,7 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-apigw-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
 export type RouteType = "route" | "page" | "app";
 export interface ResolvedRoute {

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -60,7 +60,7 @@
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "next": ">=15.5.18 <16 || >=16.2.6"
+    "next": ">=15.5.21 <16 || >=16.2.11"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"