@opennextjs/aws 3.8.2 → 3.8.4

package/dist/core/routing/routeMatcher.js

@@ -63,8 +63,8 @@ function getStaticAPIRoutes() {
         .map(createRouteDefinition);
     // We filter out both static API and page routes from the app paths manifest
     const appPathsStaticAPIRoutes = Object.values(AppPathRoutesManifest)
-        .filter((route) => route.startsWith("/api/") ||
-        (route === "/api" && !dynamicRoutePages.has(route)))
+        .filter((route) => (route.startsWith("/api/") || route === "/api") &&
+        !dynamicRoutePages.has(route))
         .map(createRouteDefinition);
     return [...pagesStaticAPIRoutes, ...appPathsStaticAPIRoutes];
 }

package/dist/core/routing/util.js

@@ -126,6 +126,8 @@ export function convertToQueryString(query) {
  * @__PURE__
  */
 export function convertToQuery(querystring) {
+    if (!querystring)
+        return {};
     const query = new URLSearchParams(querystring);
     const queryObject = {};
     for (const key of query.keys()) {

package/dist/overrides/converters/aws-apigw-v2.js

@@ -47,8 +47,10 @@ function normalizeAPIGatewayProxyEventV2Headers(event) {
     if (Array.isArray(cookies)) {
         headers.cookie = cookies.join("; ");
     }
-    for (const [key, value] of Object.entries(rawHeaders || {})) {
-        headers[key.toLowerCase()] = value;
+    if (rawHeaders) {
+        for (const [key, value] of Object.entries(rawHeaders)) {
+            headers[key.toLowerCase()] = value;
+        }
     }
     return headers;
 }

package/dist/overrides/converters/aws-cloudfront.js

@@ -48,9 +48,10 @@ const cloudfrontReadOnlyHeaders = [
 function normalizeCloudFrontRequestEventHeaders(rawHeaders) {
     const headers = {};
     for (const [key, values] of Object.entries(rawHeaders)) {
+        const lowerKey = key.toLowerCase();
         for (const { value } of values) {
             if (value) {
-                headers[key.toLowerCase()] = value;
+                headers[lowerKey] = value;
             }
         }
     }

package/dist/overrides/converters/edge.js

@@ -9,8 +9,6 @@ const converter = {
         const url = new URL(event.url);
         const searchParams = url.searchParams;
         const query = getQueryFromSearchParams(searchParams);
-        // Transform body into Buffer
-        const body = await event.arrayBuffer();
         const headers = {};
         event.headers.forEach((value, key) => {
             headers[key] = value;
@@ -18,6 +16,10 @@ const converter = {
         const rawPath = url.pathname;
         const method = event.method;
         const shouldHaveBody = method !== "GET" && method !== "HEAD";
+        // Only read body for methods that should have one
+        const body = shouldHaveBody
+            ? Buffer.from(await event.arrayBuffer())
+            : undefined;
         const cookieHeader = event.headers.get("cookie");
         const cookies = cookieHeader
             ? cookieParser.parse(cookieHeader)
@@ -27,7 +29,7 @@ const converter = {
             method,
             rawPath,
             url: event.url,
-            body: shouldHaveBody ? Buffer.from(body) : undefined,
+            body,
             headers,
             remoteAddress: event.headers.get("x-forwarded-for") ?? "::1",
             query,

package/dist/overrides/originResolver/pattern-env.js

@@ -1,31 +1,61 @@
 import { debug, error } from "../../adapters/logger";
+// Cache parsed origins and compiled patterns at module level
+let cachedOrigins;
+const cachedPatterns = [];
+let initialized = false;
+/**
+ * Initializes the cached values on the first execution
+ */
+function initializeOnce() {
+    if (initialized)
+        return;
+    // Parse origin JSON once
+    cachedOrigins = JSON.parse(process.env.OPEN_NEXT_ORIGIN ?? "{}");
+    // Pre-compile all regex patterns
+    const functions = globalThis.openNextConfig.functions ?? {};
+    for (const key in functions) {
+        if (key !== "default") {
+            const value = functions[key];
+            const regexes = [];
+            for (const pattern of value.patterns) {
+                // Convert cloudfront pattern to regex
+                const regexPattern = `/${pattern
+                    .replace(/\*\*/g, "(.*)")
+                    .replace(/\*/g, "([^/]*)")
+                    .replace(/\//g, "\\/")
+                    .replace(/\?/g, ".")}`;
+                regexes.push(new RegExp(regexPattern));
+            }
+            cachedPatterns.push({
+                key,
+                patterns: value.patterns,
+                regexes,
+            });
+        }
+    }
+    initialized = true;
+}
 const envLoader = {
     name: "env",
     resolve: async (_path) => {
         try {
-            const origin = JSON.parse(process.env.OPEN_NEXT_ORIGIN ?? "{}");
-            for (const [key, value] of Object.entries(globalThis.openNextConfig.functions ?? {}).filter(([key]) => key !== "default")) {
-                if (value.patterns.some((pattern) => {
-                    // Convert cloudfront pattern to regex
-                    return new RegExp(
-                    // transform glob pattern to regex
-                    `/${pattern
-                        .replace(/\*\*/g, "(.*)")
-                        .replace(/\*/g, "([^/]*)")
-                        .replace(/\//g, "\\/")
-                        .replace(/\?/g, ".")}`).test(_path);
-                })) {
-                    debug("Using origin", key, value.patterns);
-                    return origin[key];
+            initializeOnce();
+            // Test against pre-compiled patterns
+            for (const { key, patterns, regexes } of cachedPatterns) {
+                for (const regex of regexes) {
+                    if (regex.test(_path)) {
+                        debug("Using origin", key, patterns);
+                        return cachedOrigins[key];
+                    }
                 }
             }
-            if (_path.startsWith("/_next/image") && origin.imageOptimizer) {
+            if (_path.startsWith("/_next/image") && cachedOrigins.imageOptimizer) {
                 debug("Using origin", "imageOptimizer", _path);
-                return origin.imageOptimizer;
+                return cachedOrigins.imageOptimizer;
             }
-            if (origin.default) {
-                debug("Using default origin", origin.default, _path);
-                return origin.default;
+            if (cachedOrigins.default) {
+                debug("Using default origin", cachedOrigins.default, _path);
+                return cachedOrigins.default;
             }
             return false;
         }

package/dist/overrides/wrappers/cloudflare-node.js

@@ -25,18 +25,55 @@ const handler = async (handler, converter) => async (request, env, ctx, abortSig
             if (url.hostname === "localhost") {
                 responseHeaders.set("Content-Encoding", "identity");
             }
-            const { readable, writable } = new TransformStream({
-                transform(chunk, controller) {
-                    controller.enqueue(Uint8Array.from(chunk.chunk ?? chunk));
+            // Optimize: skip ReadableStream creation for null body statuses
+            if (NULL_BODY_STATUSES.has(statusCode)) {
+                const response = new Response(null, {
+                    status: statusCode,
+                    headers: responseHeaders,
+                });
+                resolveResponse(response);
+                // Return a no-op Writable that discards all data
+                return new Writable({
+                    write(chunk, encoding, callback) {
+                        callback();
+                    },
+                });
+            }
+            let controller;
+            const readable = new ReadableStream({
+                start(c) {
+                    controller = c;
                 },
             });
-            const body = NULL_BODY_STATUSES.has(statusCode) ? null : readable;
-            const response = new Response(body, {
+            const response = new Response(readable, {
                 status: statusCode,
                 headers: responseHeaders,
             });
             resolveResponse(response);
-            return Writable.fromWeb(writable);
+            return new Writable({
+                write(chunk, encoding, callback) {
+                    controller.enqueue(chunk);
+                    callback();
+                },
+                final(callback) {
+                    controller.close();
+                    callback();
+                },
+                destroy(error, callback) {
+                    if (error) {
+                        controller.error(error);
+                    }
+                    else {
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                            // Ignore "This ReadableStream is closed" error
+                        }
+                    }
+                    callback(error);
+                },
+            });
         },
         // This is for passing along the original abort signal from the initial Request you retrieve in your worker
         // Ensures that the response we pass to NextServer is aborted if the request is aborted

package/package.json

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