@opennextjs/aws 3.8.1 → 3.8.3

package/README.md

@@ -98,7 +98,28 @@ To run `OpenNext` locally:
 
 There is also a way to run OpenNext locally. You can read a guide about it [here](https://opennext.js.org/aws/contribute/local_run). Its mostly used for development/debugging purposes.
 
-### Coldstart
+## Testing
+
+You can run unit tests with
+
+```bash
+pnpm test
+```
+
+You can tun e2e locally with:
+
+```bash
+pnpm -r openbuild:local
+pnpm -r openbuild:local:start
+```
+
+And in a different shell:
+
+```bash
+pnpm e2e:test
+```
+
+## Coldstart
 
 OpenNext provide you with a warmer function that can be used to reduce cold start.
 

package/dist/build/createImageOptimizationBundle.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
+import os from "node:os";
 import path from "node:path";
 import logger from "../logger.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
@@ -74,10 +75,14 @@ export async function createImageOptimizationBundle(options) {
     // Target should be same as used by Lambda, see https://github.com/sst/sst/blob/ca6f763fdfddd099ce2260202d0ce48c72e211ea/packages/sst/src/constructs/NextjsSite.ts#L114
     // For SHARP_IGNORE_GLOBAL_LIBVIPS see: https://github.com/lovell/sharp/blob/main/docs/install.md#aws-lambda
     const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
+    // In development, we want to use the local machine settings
+    const isDev = config.imageOptimization?.loader === "fs-dev";
     installDependencies(outputPath, config.imageOptimization?.install ?? {
         packages: [`sharp@${sharpVersion}`],
-        // By not specifying an arch, `npm install` will choose one for us (i.e. our system one)
-        arch: config.imageOptimization?.loader === "fs-dev" ? undefined : "arm64",
+        // By not specifying an arch in dev, `npm install` will choose one for us (i.e. our system one)
+        arch: isDev ? undefined : "arm64",
+        // Use the local platform in dev
+        os: isDev ? os.platform() : "linux",
         nodeVersion: "18",
         libc: "glibc",
     });

package/dist/build/installDeps.js

@@ -24,8 +24,9 @@ export function installDependencies(outputDir, installOptions) {
         const libcOption = installOptions.libc
             ? `--libc=${installOptions.libc}`
             : "";
+        const osOption = `--os=${installOptions.os ?? "linux"}`;
         const additionalArgs = installOptions.additionalArgs ?? "";
-        const installCommand = `npm install --platform=linux ${archOption} ${targetOption} ${libcOption} ${additionalArgs} ${installOptions.packages.join(" ")}`;
+        const installCommand = `npm install ${osOption} ${archOption} ${targetOption} ${libcOption} ${additionalArgs} ${installOptions.packages.join(" ")}`;
         execSync(installCommand, {
             stdio: "pipe",
             cwd: tempInstallDir,

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()) {
@@ -177,13 +179,12 @@ export function convertBodyToReadableStream(method, body) {
         return undefined;
     if (!body)
         return undefined;
-    const readable = new ReadableStream({
+    return new ReadableStream({
         start(controller) {
             controller.enqueue(body);
             controller.close();
         },
     });
-    return readable;
 }
 var CommonHeaders;
 (function (CommonHeaders) {

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,50 @@ 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 {
+                        controller.close();
+                    }
+                    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/dist/types/open-next.d.ts

@@ -190,18 +190,14 @@ export interface InstallOptions {
      * ```
      */
     packages: string[];
-    /**
-     * @default undefined
-     */
+    /** @default undefined */
     arch?: "x64" | "arm64";
-    /**
-     * @default undefined
-     */
+    /** @default undefined */
     nodeVersion?: string;
-    /**
-     * @default undefined
-     */
+    /** @default undefined */
     libc?: "glibc" | "musl";
+    /** @default "linux" */
+    os?: string;
     /**
      * @default undefined
      * Additional arguments to pass to the install command (i.e. npm install)

package/dist/utils/binary.js

@@ -61,6 +61,6 @@ const commonBinaryMimeTypes = new Set([
 export function isBinaryContentType(contentType) {
     if (!contentType)
         return false;
-    const value = contentType?.split(";")[0] ?? "";
+    const value = contentType.split(";")[0];
     return commonBinaryMimeTypes.has(value);
 }

package/dist/utils/fetch.js

@@ -17,7 +17,6 @@ export function customFetchClient(client) {
          * This is necessary otherwise we get some error : SocketError: other side closed
          * https://github.com/nodejs/undici/issues/583#issuecomment-855384858
          */
-        const clonedResponse = response.clone();
-        return clonedResponse;
+        return response.clone();
     };
 }

package/dist/utils/stream.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableStream } from "node:stream/web";
+import { ReadableStream } from "node:stream/web";
 export declare function fromReadableStream(stream: ReadableStream<Uint8Array>, base64?: boolean): Promise<string>;
 export declare function toReadableStream(value: string, isBase64?: boolean): ReadableStream;
 export declare function emptyReadableStream(): ReadableStream;

package/dist/utils/stream.js

@@ -1,30 +1,49 @@
-import { Readable } from "node:stream";
-export function fromReadableStream(stream, base64) {
-    const reader = stream.getReader();
+import { ReadableStream } from "node:stream/web";
+export async function fromReadableStream(stream, base64) {
     const chunks = [];
-    return new Promise((resolve, reject) => {
-        function pump() {
-            reader
-                .read()
-                .then(({ done, value }) => {
-                if (done) {
-                    resolve(Buffer.concat(chunks).toString(base64 ? "base64" : "utf8"));
-                    return;
-                }
-                chunks.push(value);
-                pump();
-            })
-                .catch(reject);
-        }
-        pump();
-    });
+    let totalLength = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    if (chunks.length === 0) {
+        return "";
+    }
+    if (chunks.length === 1) {
+        return Buffer.from(chunks[0]).toString(base64 ? "base64" : "utf8");
+    }
+    // Pre-allocate buffer with exact size to avoid reallocation
+    const buffer = Buffer.alloc(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return buffer.toString(base64 ? "base64" : "utf8");
 }
 export function toReadableStream(value, isBase64) {
-    return Readable.toWeb(Readable.from(Buffer.from(value, isBase64 ? "base64" : "utf8")));
+    return new ReadableStream({
+        pull(controller) {
+            // Defer the Buffer.from conversion to when the stream is actually read.
+            controller.enqueue(Buffer.from(value, isBase64 ? "base64" : "utf8"));
+            controller.close();
+        },
+    }, { highWaterMark: 0 });
 }
+let maybeSomethingBuffer;
 export function emptyReadableStream() {
     if (process.env.OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE === "true") {
-        return Readable.toWeb(Readable.from([Buffer.from("SOMETHING")]));
+        return new ReadableStream({
+            pull(controller) {
+                maybeSomethingBuffer ??= Buffer.from("SOMETHING");
+                controller.enqueue(maybeSomethingBuffer);
+                controller.close();
+            },
+        }, { highWaterMark: 0 });
     }
-    return Readable.toWeb(Readable.from([]));
+    return new ReadableStream({
+        start(controller) {
+            controller.close();
+        },
+    });
 }

package/package.json

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