@opennextjs/aws 3.8.1 → 3.8.2

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/util.js

@@ -177,13 +177,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/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.2",
   "bin": {
     "open-next": "./dist/index.js"
   },