@opennextjs/aws 4.0.3 → 4.1.0

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/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.3",
+  "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"