@opennextjs/aws 3.1.4

package/dist/helpers/withCloudflare.d.ts

@@ -0,0 +1,65 @@
+import { FunctionOptions, OpenNextConfig, RouteTemplate, SplittedFunctionOptions } from "../types/open-next";
+type CloudflareCompatibleFunction<Placement extends "regional" | "global"> = Placement extends "regional" ? FunctionOptions & {
+    placement: "regional";
+} : {
+    placement: "global";
+};
+type CloudflareCompatibleRoutes<Placement extends "regional" | "global"> = Placement extends "regional" ? {
+    placement: "regional";
+    routes: RouteTemplate[];
+    patterns: string[];
+} : {
+    placement: "global";
+    routes: `app/${string}/route`;
+    patterns: string;
+};
+type CloudflareCompatibleSplittedFunction<Placement extends "regional" | "global" = "regional"> = CloudflareCompatibleRoutes<Placement> & CloudflareCompatibleFunction<Placement>;
+type CloudflareConfig<Fn extends Record<string, CloudflareCompatibleSplittedFunction<"global" | "regional">>> = {
+    default: CloudflareCompatibleFunction<"regional">;
+    functions?: Fn;
+} & Omit<OpenNextConfig, "default" | "functions" | "middleware">;
+type InterpolatedSplittedFunctionOptions<Fn extends Record<string, CloudflareCompatibleSplittedFunction<"global" | "regional">>> = {
+    [K in keyof Fn]: SplittedFunctionOptions;
+};
+/**
+ * This function makes it easier to use Cloudflare with OpenNext.
+ * All options are already restricted to Cloudflare compatible options.
+ * @example
+ * ```ts
+ export default withCloudflare({
+  default: {
+    placement: "regional",
+    runtime: "node",
+  },
+  functions: {
+    api: {
+      placement: "regional",
+      runtime: "node",
+      routes: ["app/api/test/route", "page/api/otherApi"],
+      patterns: ["/api/*"],
+    },
+    global: {
+      placement: "global",
+      runtime: "edge",
+      routes: "app/test/page",
+      patterns: "/page",
+    },
+  },
+});
+ * ```
+ */
+export declare function withCloudflare<Fn extends Record<string, CloudflareCompatibleSplittedFunction<"global" | "regional">>, Key extends keyof Fn>(config: CloudflareConfig<Fn>): {
+    default: FunctionOptions & {
+        placement: "regional";
+    };
+    functions: InterpolatedSplittedFunctionOptions<Fn>;
+    middleware: {
+        external: true;
+        originResolver: "pattern-env";
+        override: {
+            wrapper: "cloudflare";
+            converter: "edge";
+        };
+    };
+};
+export {};

package/dist/helpers/withCloudflare.js

@@ -0,0 +1,58 @@
+/**
+ * This function makes it easier to use Cloudflare with OpenNext.
+ * All options are already restricted to Cloudflare compatible options.
+ * @example
+ * ```ts
+ export default withCloudflare({
+  default: {
+    placement: "regional",
+    runtime: "node",
+  },
+  functions: {
+    api: {
+      placement: "regional",
+      runtime: "node",
+      routes: ["app/api/test/route", "page/api/otherApi"],
+      patterns: ["/api/*"],
+    },
+    global: {
+      placement: "global",
+      runtime: "edge",
+      routes: "app/test/page",
+      patterns: "/page",
+    },
+  },
+});
+ * ```
+ */
+export function withCloudflare(config) {
+    const functions = Object.entries(config.functions ?? {}).reduce((acc, [name, fn]) => {
+        const _name = name;
+        acc[_name] =
+            fn.placement === "global"
+                ? {
+                    placement: "global",
+                    runtime: "edge",
+                    routes: [fn.routes],
+                    patterns: [fn.patterns],
+                    override: {
+                        wrapper: "cloudflare",
+                        converter: "edge",
+                    },
+                }
+                : { ...fn, placement: "regional" };
+        return acc;
+    }, {});
+    return {
+        default: config.default,
+        functions: functions,
+        middleware: {
+            external: true,
+            originResolver: "pattern-env",
+            override: {
+                wrapper: "cloudflare",
+                converter: "edge",
+            },
+        },
+    };
+}

package/dist/helpers/withSST.d.ts

@@ -0,0 +1,54 @@
+import { FunctionOptions, OpenNextConfig, RouteTemplate } from "../types/open-next";
+type SSTCompatibleFunction = FunctionOptions & {
+    override?: {
+        wrapper?: "aws-lambda-streaming" | "aws-lambda";
+        converter?: "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront";
+    };
+};
+type SSTCompatibleSplittedFunction = {
+    routes: RouteTemplate[];
+    patterns: string[];
+} & SSTCompatibleFunction;
+type SSTCompatibleConfig<Fn extends Record<string, SSTCompatibleSplittedFunction>> = {
+    default: SSTCompatibleFunction;
+    functions?: Fn;
+    middleware?: {
+        external: true;
+    };
+} & Pick<OpenNextConfig, "dangerous" | "appPath" | "buildCommand" | "buildOutputPath" | "packageJsonPath">;
+/**
+ * This function makes it more straightforward to use SST with OpenNext.
+ * All options are already restricted to SST compatible options only.
+ * Some options not present here can be used in SST, but it's an advanced use case that
+ * can easily break the deployment. If you need to use those options, you should just provide a
+ * compatible OpenNextConfig inside your `open-next.config.ts` file.
+ * @example
+ * ```ts
+  export default withSST({
+    default: {
+      override: {
+        wrapper: "aws-lambda-streaming",
+      },
+    },
+    functions: {
+      "api/*": {
+        routes: ["app/api/test/route", "page/api/otherApi"],
+        patterns: ["/api/*"],
+      },
+    },
+  });
+ * ```
+ */
+export declare function withSST<Fn extends Record<string, SSTCompatibleSplittedFunction>>(config: SSTCompatibleConfig<Fn>): {
+    default: SSTCompatibleFunction;
+    functions?: Fn | undefined;
+    middleware?: {
+        external: true;
+    } | undefined;
+    dangerous?: import("../types/open-next").DangerousOptions | undefined;
+    buildCommand?: string | undefined;
+    buildOutputPath?: string | undefined;
+    appPath?: string | undefined;
+    packageJsonPath?: string | undefined;
+};
+export {};

package/dist/helpers/withSST.js

@@ -0,0 +1,28 @@
+/**
+ * This function makes it more straightforward to use SST with OpenNext.
+ * All options are already restricted to SST compatible options only.
+ * Some options not present here can be used in SST, but it's an advanced use case that
+ * can easily break the deployment. If you need to use those options, you should just provide a
+ * compatible OpenNextConfig inside your `open-next.config.ts` file.
+ * @example
+ * ```ts
+  export default withSST({
+    default: {
+      override: {
+        wrapper: "aws-lambda-streaming",
+      },
+    },
+    functions: {
+      "api/*": {
+        routes: ["app/api/test/route", "page/api/otherApi"],
+        patterns: ["/api/*"],
+      },
+    },
+  });
+ * ```
+ */
+export function withSST(config) {
+    return {
+        ...config,
+    };
+}

package/dist/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./openNextResponse.js";
+export * from "./request.js";

package/dist/http/index.js

@@ -0,0 +1,4 @@
+// @__PURE__
+export * from "./openNextResponse.js";
+// @__PURE__
+export * from "./request.js";

package/dist/http/openNextResponse.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "http";
+import { Socket } from "net";
+import { Transform, TransformCallback, Writable } from "stream";
+export interface StreamCreator {
+    writeHeaders(prelude: {
+        statusCode: number;
+        cookies: string[];
+        headers: Record<string, string>;
+    }): Writable;
+    onWrite?: () => void;
+    onFinish: (length: number) => void;
+}
+export declare class OpenNextNodeResponse extends Transform implements ServerResponse {
+    private fixHeaders;
+    private streamCreator?;
+    private initialHeaders?;
+    statusCode: number;
+    statusMessage: string;
+    headers: OutgoingHttpHeaders;
+    private _cookies;
+    private responseStream?;
+    headersSent: boolean;
+    _chunks: Buffer[];
+    strictContentLength: boolean;
+    assignSocket(_socket: Socket): void;
+    detachSocket(_socket: Socket): void;
+    writeContinue(_callback?: (() => void) | undefined): void;
+    writeEarlyHints(_hints: Record<string, string | string[]>, _callback?: (() => void) | undefined): void;
+    writeProcessing(): void;
+    /**
+     * This is a dummy request object to comply with the ServerResponse interface
+     * It will never be defined
+     */
+    req: IncomingMessage;
+    chunkedEncoding: boolean;
+    shouldKeepAlive: boolean;
+    useChunkedEncodingByDefault: boolean;
+    sendDate: boolean;
+    connection: Socket | null;
+    socket: Socket | null;
+    setTimeout(_msecs: number, _callback?: (() => void) | undefined): this;
+    addTrailers(_headers: OutgoingHttpHeaders | readonly [string, string][]): void;
+    constructor(fixHeaders: (headers: OutgoingHttpHeaders) => void, onEnd: (headers: OutgoingHttpHeaders) => Promise<void>, streamCreator?: StreamCreator | undefined, initialHeaders?: OutgoingHttpHeaders | undefined);
+    get originalResponse(): this;
+    get finished(): boolean;
+    setHeader(name: string, value: string | string[]): this;
+    removeHeader(name: string): this;
+    hasHeader(name: string): boolean;
+    getHeaders(): OutgoingHttpHeaders;
+    getHeader(name: string): OutgoingHttpHeader | undefined;
+    getHeaderNames(): string[];
+    flushHeaders(): void;
+    appendHeader(name: string, value: string | string[]): this;
+    writeHead(statusCode: number, statusMessage?: string | undefined, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined): this;
+    writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined): this;
+    /**
+     * OpenNext specific method
+     */
+    getFixedHeaders(): OutgoingHttpHeaders;
+    getBody(): Buffer;
+    private _internalWrite;
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    /**
+     * Next specific methods
+     * On earlier versions of next.js, those methods are mandatory to make everything work
+     */
+    get sent(): boolean;
+    getHeaderValues(name: string): string[] | undefined;
+    send(): void;
+    body(value: string): this;
+    onClose(callback: () => void): void;
+    redirect(destination: string, statusCode: number): this;
+}

package/dist/http/openNextResponse.js

@@ -0,0 +1,281 @@
+import { Transform } from "stream";
+import { debug } from "../adapters/logger";
+import { parseCookies, parseHeaders } from "./util";
+const SET_COOKIE_HEADER = "set-cookie";
+const CANNOT_BE_USED = "This cannot be used in OpenNext";
+// We only need to implement the methods that are used by next.js
+export class OpenNextNodeResponse extends Transform {
+    fixHeaders;
+    streamCreator;
+    initialHeaders;
+    statusCode;
+    statusMessage = "";
+    headers = {};
+    _cookies = [];
+    responseStream;
+    headersSent = false;
+    _chunks = [];
+    // To comply with the ServerResponse interface :
+    strictContentLength = false;
+    assignSocket(_socket) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    detachSocket(_socket) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    // We might have to revisit those 3 in the future
+    writeContinue(_callback) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    writeEarlyHints(_hints, _callback) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    writeProcessing() {
+        throw new Error(CANNOT_BE_USED);
+    }
+    /**
+     * This is a dummy request object to comply with the ServerResponse interface
+     * It will never be defined
+     */
+    req;
+    chunkedEncoding = false;
+    shouldKeepAlive = true;
+    useChunkedEncodingByDefault = true;
+    sendDate = false;
+    connection = null;
+    socket = null;
+    setTimeout(_msecs, _callback) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    addTrailers(_headers) {
+        throw new Error(CANNOT_BE_USED);
+    }
+    constructor(fixHeaders, onEnd, streamCreator, initialHeaders) {
+        super();
+        this.fixHeaders = fixHeaders;
+        this.streamCreator = streamCreator;
+        this.initialHeaders = initialHeaders;
+        this.once("finish", () => {
+            if (!this.headersSent) {
+                this.flushHeaders();
+            }
+            // In some cases we might not have a store i.e. for example in the image optimization function
+            // We may want to reconsider this in the future, it might be intersting to have access to this store everywhere
+            globalThis.__als
+                ?.getStore()
+                ?.pendingPromiseRunner.add(onEnd(this.headers));
+            const bodyLength = this.getBody().length;
+            this.streamCreator?.onFinish(bodyLength);
+        });
+    }
+    // Necessary for next 12
+    // We might have to implement all the methods here
+    get originalResponse() {
+        return this;
+    }
+    get finished() {
+        return Boolean(this.writableFinished && this.responseStream?.writableFinished);
+    }
+    setHeader(name, value) {
+        const key = name.toLowerCase();
+        if (key === SET_COOKIE_HEADER) {
+            if (Array.isArray(value)) {
+                this._cookies = value;
+            }
+            else {
+                this._cookies = [value];
+            }
+        }
+        // We should always replace the header
+        // See https://nodejs.org/docs/latest-v18.x/api/http.html#responsesetheadername-value
+        this.headers[key] = value;
+        return this;
+    }
+    removeHeader(name) {
+        const key = name.toLowerCase();
+        if (key === SET_COOKIE_HEADER) {
+            this._cookies = [];
+        }
+        else {
+            delete this.headers[key];
+        }
+        return this;
+    }
+    hasHeader(name) {
+        const key = name.toLowerCase();
+        if (key === SET_COOKIE_HEADER) {
+            return this._cookies.length > 0;
+        }
+        return this.headers[key] !== undefined;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    getHeader(name) {
+        return this.headers[name.toLowerCase()];
+    }
+    getHeaderNames() {
+        return Object.keys(this.headers);
+    }
+    // Only used directly in next@14+
+    flushHeaders() {
+        this.headersSent = true;
+        // Initial headers should be merged with the new headers
+        // These initial headers are the one created either in the middleware or in next.config.js
+        const mergeHeadersPriority = globalThis.__als?.getStore()?.mergeHeadersPriority ?? "middleware";
+        if (this.initialHeaders) {
+            this.headers =
+                mergeHeadersPriority === "middleware"
+                    ? {
+                        ...this.headers,
+                        ...this.initialHeaders,
+                    }
+                    : {
+                        ...this.initialHeaders,
+                        ...this.headers,
+                    };
+            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER] ?? []);
+            this._cookies =
+                mergeHeadersPriority === "middleware"
+                    ? [...this._cookies, ...initialCookies]
+                    : [...initialCookies, ...this._cookies];
+        }
+        this.fixHeaders(this.headers);
+        // We need to fix the set-cookie header here
+        this.headers[SET_COOKIE_HEADER] = this._cookies;
+        const parsedHeaders = parseHeaders(this.headers);
+        // We need to remove the set-cookie header from the parsed headers because
+        // it does not handle multiple set-cookie headers properly
+        delete parsedHeaders[SET_COOKIE_HEADER];
+        if (this.streamCreator) {
+            this.responseStream = this.streamCreator?.writeHeaders({
+                statusCode: this.statusCode ?? 200,
+                cookies: this._cookies,
+                headers: parsedHeaders,
+            });
+            this.pipe(this.responseStream);
+        }
+    }
+    appendHeader(name, value) {
+        const key = name.toLowerCase();
+        if (!this.hasHeader(key)) {
+            return this.setHeader(key, value);
+        }
+        else {
+            const existingHeader = this.getHeader(key);
+            const toAppend = Array.isArray(value) ? value : [value];
+            const newValue = Array.isArray(existingHeader)
+                ? [...existingHeader, ...toAppend]
+                : [existingHeader, ...toAppend];
+            return this.setHeader(key, newValue);
+        }
+    }
+    writeHead(statusCode, statusMessage, headers) {
+        let _headers = headers;
+        let _statusMessage;
+        if (typeof statusMessage === "string") {
+            _statusMessage = statusMessage;
+        }
+        else {
+            _headers = statusMessage;
+        }
+        const finalHeaders = this.headers;
+        if (_headers) {
+            if (Array.isArray(_headers)) {
+                // headers may be an Array where the keys and values are in the same list. It is not a list of tuples. So, the even-numbered offsets are key values, and the odd-numbered offsets are the associated values.
+                for (let i = 0; i < _headers.length; i += 2) {
+                    finalHeaders[_headers[i]] = _headers[i + 1];
+                }
+            }
+            else {
+                for (const key of Object.keys(_headers)) {
+                    finalHeaders[key] = _headers[key];
+                }
+            }
+        }
+        this.statusCode = statusCode;
+        if (headers) {
+            this.headers = finalHeaders;
+        }
+        this.flushHeaders();
+        return this;
+    }
+    /**
+     * OpenNext specific method
+     */
+    getFixedHeaders() {
+        // Do we want to apply this on writeHead?
+        this.fixHeaders(this.headers);
+        // This way we ensure that the cookies are correct
+        this.headers[SET_COOKIE_HEADER] = this._cookies;
+        return this.headers;
+    }
+    getBody() {
+        return Buffer.concat(this._chunks);
+    }
+    _internalWrite(chunk, encoding) {
+        this._chunks.push(Buffer.from(chunk, encoding));
+        this.push(chunk, encoding);
+        this.streamCreator?.onWrite?.();
+    }
+    _transform(chunk, encoding, callback) {
+        if (!this.headersSent) {
+            this.flushHeaders();
+        }
+        this._internalWrite(chunk, encoding);
+        callback();
+    }
+    //This is only here because of aws broken streaming implementation.
+    //Hopefully one day they will be able to give us a working streaming implementation in lambda for everyone
+    //If you're lucky you have a working streaming implementation in your aws account and don't need this
+    //If not you can set the OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE env variable to true
+    //BE CAREFUL: Aws keeps rolling out broken streaming implementations even on accounts that had working ones before
+    //This is not dependent on the node runtime used
+    //There is another known issue with aws lambda streaming where the request reach the lambda only way after the request has been sent by the client. For this there is absolutely nothing we can do, contact aws support if that's your case
+    _flush(callback) {
+        if (this.getBody().length < 1 &&
+            // We use an env variable here because not all aws account have the same behavior
+            // On some aws accounts the response will hang if the body is empty
+            // We are modifying the response body here, this is not a good practice
+            process.env.OPEN_NEXT_FORCE_NON_EMPTY_RESPONSE === "true") {
+            debug('Force writing "SOMETHING" to the response body');
+            this.push("SOMETHING");
+        }
+        callback();
+    }
+    /**
+     * Next specific methods
+     * On earlier versions of next.js, those methods are mandatory to make everything work
+     */
+    get sent() {
+        return this.finished || this.headersSent;
+    }
+    getHeaderValues(name) {
+        const values = this.getHeader(name);
+        if (values === undefined)
+            return undefined;
+        return (Array.isArray(values) ? values : [values]).map((value) => value.toString());
+    }
+    send() {
+        const body = this.getBody();
+        this.end(body);
+    }
+    body(value) {
+        this.write(value);
+        return this;
+    }
+    onClose(callback) {
+        this.on("close", callback);
+    }
+    redirect(destination, statusCode) {
+        this.setHeader("Location", destination);
+        this.statusCode = statusCode;
+        // Since IE11 doesn't support the 308 header add backwards
+        // compatibility using refresh header
+        if (statusCode === 308) {
+            this.setHeader("Refresh", `0;url=${destination}`);
+        }
+        //TODO: test to see if we need to call end here
+        return this;
+    }
+}

package/dist/http/request.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from "node:http";
+export declare class IncomingMessage extends http.IncomingMessage {
+    constructor({ method, url, headers, body, remoteAddress, }: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: Buffer;
+        remoteAddress: string;
+    });
+}

package/dist/http/request.js

@@ -0,0 +1,35 @@
+// Copied and modified from serverless-http by Doug Moscrop
+// https://github.com/dougmoscrop/serverless-http/blob/master/lib/request.js
+// Licensed under the MIT License
+// @ts-nocheck
+import http from "node:http";
+export class IncomingMessage extends http.IncomingMessage {
+    constructor({ method, url, headers, body, remoteAddress, }) {
+        super({
+            encrypted: true,
+            readable: false,
+            remoteAddress,
+            address: () => ({ port: 443 }),
+            end: Function.prototype,
+            destroy: Function.prototype,
+        });
+        if (typeof headers["content-length"] === "undefined") {
+            headers["content-length"] = Buffer.byteLength(body).toString();
+        }
+        Object.assign(this, {
+            ip: remoteAddress,
+            complete: true,
+            httpVersion: "1.1",
+            httpVersionMajor: "1",
+            httpVersionMinor: "1",
+            method,
+            headers,
+            body,
+            url,
+        });
+        this._read = () => {
+            this.push(body);
+            this.push(null);
+        };
+    }
+}

package/dist/http/util.d.ts

@@ -0,0 +1,4 @@
+import http from "node:http";
+export declare const parseHeaders: (headers?: http.OutgoingHttpHeader[] | http.OutgoingHttpHeaders) => Record<string, string>;
+export declare const convertHeader: (header: http.OutgoingHttpHeader) => string;
+export declare function parseCookies(cookies?: string | string[]): string[] | undefined;

package/dist/http/util.js

@@ -0,0 +1,34 @@
+export const parseHeaders = (headers) => {
+    const result = {};
+    if (!headers) {
+        return result;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        else {
+            result[key.toLowerCase()] = convertHeader(value);
+        }
+    }
+    return result;
+};
+export const convertHeader = (header) => {
+    if (typeof header === "string") {
+        return header;
+    }
+    else if (Array.isArray(header)) {
+        return header.join(",");
+    }
+    else {
+        return String(header);
+    }
+};
+export function parseCookies(cookies) {
+    if (!cookies)
+        return;
+    if (typeof cookies === "string") {
+        return cookies.split(/(?<!Expires=\w+),/i).map((c) => c.trim());
+    }
+    return cookies;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};