@opennextjs/aws 3.1.4

package/dist/utils/stream.js

@@ -0,0 +1,30 @@
+import { Readable } from "node:stream";
+export function fromReadableStream(stream, base64) {
+    const reader = stream.getReader();
+    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();
+    });
+}
+export function toReadableStream(value, isBase64) {
+    return Readable.toWeb(Readable.from(Buffer.from(value, isBase64 ? "base64" : "utf8")));
+}
+export function emptyReadableStream() {
+    if (process.env.OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE === "true") {
+        return Readable.toWeb(Readable.from([Buffer.from("SOMETHING")]));
+    }
+    return Readable.toWeb(Readable.from([]));
+}

package/dist/wrappers/aws-lambda-streaming.d.ts

@@ -0,0 +1,7 @@
+import { WrapperHandler } from "../types/open-next";
+declare const _default: {
+    wrapper: WrapperHandler<import("../types/open-next").InternalEvent, import("../types/open-next").InternalResult>;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/wrappers/aws-lambda-streaming.js

@@ -0,0 +1,88 @@
+import { Readable } from "node:stream";
+import zlib from "node:zlib";
+import { debug, error } from "../adapters/logger";
+function formatWarmerResponse(event) {
+    const result = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({ serverId, type: "warmer" });
+        }, event.delay);
+    });
+    return result;
+}
+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");
+        return;
+    }
+    const internalEvent = await converter.convertFrom(event);
+    //Handle compression
+    const acceptEncoding = internalEvent.headers["Accept-Encoding"] ??
+        internalEvent.headers["accept-encoding"] ??
+        "";
+    let contentEncoding;
+    let compressedStream;
+    responseStream.on("error", (err) => {
+        error(err);
+        responseStream.end();
+    });
+    if (acceptEncoding.includes("br")) {
+        contentEncoding = "br";
+        compressedStream = zlib.createBrotliCompress({
+            flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+            finishFlush: zlib.constants.BROTLI_OPERATION_FINISH,
+        });
+        compressedStream.pipe(responseStream);
+    }
+    else if (acceptEncoding.includes("gzip")) {
+        contentEncoding = "gzip";
+        compressedStream = zlib.createGzip({
+            flush: zlib.constants.Z_SYNC_FLUSH,
+        });
+        compressedStream.pipe(responseStream);
+    }
+    else if (acceptEncoding.includes("deflate")) {
+        contentEncoding = "deflate";
+        compressedStream = zlib.createDeflate({
+            flush: zlib.constants.Z_SYNC_FLUSH,
+        });
+        compressedStream.pipe(responseStream);
+    }
+    else {
+        contentEncoding = "identity";
+        compressedStream = responseStream;
+    }
+    const streamCreator = {
+        writeHeaders: (_prelude) => {
+            _prelude.headers["content-encoding"] = contentEncoding;
+            responseStream.setContentType("application/vnd.awslambda.http-integration-response");
+            _prelude.headers["content-encoding"] = contentEncoding;
+            const prelude = JSON.stringify(_prelude);
+            responseStream.write(prelude);
+            responseStream.write(new Uint8Array(8));
+            return compressedStream ?? responseStream;
+        },
+        onWrite: () => {
+            // _hasWriten = true;
+        },
+        onFinish: () => { },
+    };
+    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);
+    }
+    // return converter.convertTo(response);
+});
+export default {
+    wrapper: handler,
+    name: "aws-lambda-streaming",
+    supportStreaming: true,
+};

package/dist/wrappers/aws-lambda.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../types/open-next";
+declare const _default: {
+    wrapper: WrapperHandler<import("../types/open-next").InternalEvent, import("../types/open-next").InternalResult>;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/wrappers/aws-lambda.js

@@ -0,0 +1,39 @@
+import { Writable } from "node:stream";
+function formatWarmerResponse(event) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({ serverId, type: "warmer" });
+        }, event.delay);
+    });
+}
+const handler = async (handler, converter) => async (event) => {
+    // Handle warmer event
+    if ("type" in event) {
+        return formatWarmerResponse(event);
+    }
+    const internalEvent = await converter.convertFrom(event);
+    //TODO: create a simple reproduction and open an issue in the node repo
+    //This is a workaround, there is an issue in node that causes node to crash silently if the OpenNextNodeResponse stream is not consumed
+    //This does not happen everytime, it's probably caused by suspended component in ssr (either via <Suspense> or loading.tsx)
+    //Everyone that wish to create their own wrapper without a StreamCreator should implement this workaround
+    //This is not necessary if the underlying handler does not use OpenNextNodeResponse (At the moment, OpenNextNodeResponse is used by the node runtime servers and the image server)
+    const fakeStream = {
+        writeHeaders: () => {
+            return new Writable({
+                write: (_chunk, _encoding, callback) => {
+                    callback();
+                },
+            });
+        },
+        onFinish: () => {
+            // Do nothing
+        },
+    };
+    const response = await handler(internalEvent, fakeStream);
+    return converter.convertTo(response, event);
+};
+export default {
+    wrapper: handler,
+    name: "aws-lambda",
+    supportStreaming: false,
+};

package/dist/wrappers/cloudflare.d.ts

@@ -0,0 +1,11 @@
+import type { InternalEvent, InternalResult, WrapperHandler } from "../types/open-next";
+import { MiddlewareOutputEvent } from "../core/routingHandler";
+declare const _default: {
+    wrapper: WrapperHandler<InternalEvent, InternalResult | ({
+        type: "middleware";
+    } & MiddlewareOutputEvent)>;
+    name: string;
+    supportStreaming: boolean;
+    edgeRuntime: boolean;
+};
+export default _default;

package/dist/wrappers/cloudflare.js

@@ -0,0 +1,20 @@
+const handler = async (handler, converter) => async (event, env) => {
+    globalThis.process = process;
+    // Set the environment variables
+    // Cloudlare suggests to not override the process.env object but instead apply the values to it
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string") {
+            process.env[key] = value;
+        }
+    }
+    const internalEvent = await converter.convertFrom(event);
+    const response = await handler(internalEvent);
+    const result = await converter.convertTo(response);
+    return result;
+};
+export default {
+    wrapper: handler,
+    name: "cloudflare",
+    supportStreaming: true,
+    edgeRuntime: true,
+};

package/dist/wrappers/node.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../types/open-next";
+declare const _default: {
+    wrapper: WrapperHandler<import("../types/open-next").InternalEvent, import("../types/open-next").InternalResult>;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/wrappers/node.js

@@ -0,0 +1,57 @@
+import { createServer } from "node:http";
+import { debug, error } from "../adapters/logger";
+const wrapper = async (handler, converter) => {
+    const server = createServer(async (req, res) => {
+        const internalEvent = await converter.convertFrom(req);
+        const _res = {
+            writeHeaders: (prelude) => {
+                res.setHeader("Set-Cookie", prelude.cookies);
+                res.writeHead(prelude.statusCode, prelude.headers);
+                res.flushHeaders();
+                res.uncork();
+                return res;
+            },
+            onFinish: () => {
+                // Is it necessary to do something here?
+            },
+        };
+        if (internalEvent.rawPath === "/__health") {
+            res.writeHead(200, {
+                "Content-Type": "text/plain",
+            });
+            res.end("OK");
+        }
+        else {
+            await handler(internalEvent, _res);
+        }
+    });
+    await new Promise((resolve) => {
+        server.on("listening", () => {
+            const cleanup = (code) => {
+                debug(`Closing server`);
+                server.close(() => {
+                    debug(`Server closed`);
+                    process.exit(code);
+                });
+            };
+            console.log(`Listening on port ${process.env.PORT ?? "3000"}`);
+            debug(`Open Next version: ${process.env.OPEN_NEXT_VERSION}`);
+            process.on("exit", (code) => cleanup(code));
+            process.on("SIGINT", () => cleanup(0));
+            process.on("SIGTERM", () => cleanup(0));
+            resolve();
+        });
+        server.listen(parseInt(process.env.PORT ?? "3000", 10));
+    });
+    server.on("error", (err) => {
+        error(err);
+    });
+    return () => {
+        server.close();
+    };
+};
+export default {
+    wrapper,
+    name: "node",
+    supportStreaming: true,
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "publishConfig": {
+    "access": "public"
+  },
+  "name": "@opennextjs/aws",
+  "version": "3.1.4",
+  "bin": {
+    "open-next": "./dist/index.js",
+    "@opennextjs/aws": "./dist/index.js"
+  },
+  "license": "MIT",
+  "type": "module",
+  "description": "Open source Next.js serverless adapter",
+  "homepage": "https://open-next.js.org",
+  "main": "./dist/index.js",
+  "exports": {
+    "./*": "./dist/*"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/*"
+      ]
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "files": [
+    "dist",
+    "assets",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.398.0",
+    "@aws-sdk/client-lambda": "^3.398.0",
+    "@aws-sdk/client-s3": "^3.398.0",
+    "@aws-sdk/client-sqs": "^3.398.0",
+    "@esbuild-plugins/node-resolve": "0.2.2",
+    "@node-minify/core": "^8.0.6",
+    "@node-minify/terser": "^8.0.6",
+    "@tsconfig/node18": "^1.0.1",
+    "aws4fetch": "^1.0.18",
+    "chalk": "^5.3.0",
+    "esbuild": "0.19.2",
+    "path-to-regexp": "^6.3.0",
+    "promise.series": "^0.2.0",
+    "urlpattern-polyfill": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.109",
+    "@types/node": "^18.16.1",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^4.9.3"
+  },
+  "bugs": {
+    "url": "https://github.com/sst/open-next/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sst/open-next.git"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "dev": "tsc -w"
+  }
+}