@opennextjs/aws 3.1.4

package/dist/converters/aws-cloudfront.js

@@ -0,0 +1,170 @@
+import { parseCookies } from "../http/util";
+import { fromReadableStream } from "../utils/stream";
+import { debug } from "../adapters/logger";
+import { convertRes, convertToQuery, convertToQueryString, createServerResponse, proxyRequest, } from "../core/routing/util";
+const CloudFrontBlacklistedHeaders = [
+    // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
+    "connection",
+    "expect",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "trailer",
+    "upgrade",
+    "x-accel-buffering",
+    "x-accel-charset",
+    "x-accel-limit-rate",
+    "x-accel-redirect",
+    /x-amz-cf-(.*)/,
+    "x-amzn-auth",
+    "x-amzn-cf-billing",
+    "x-amzn-cf-id",
+    "x-amzn-cf-xff",
+    "x-amzn-errortype",
+    "x-amzn-fle-profile",
+    "x-amzn-header-count",
+    "x-amzn-header-order",
+    "x-amzn-lambda-integration-tag",
+    "x-amzn-requestid",
+    /x-edge-(.*)/,
+    "x-cache",
+    "x-forwarded-proto",
+    "x-real-ip",
+];
+// Read-only headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-read-only-headers
+// We should only remove these headers when directly responding in lambda@edge, not for the external middleware
+const cloudfrontReadOnlyHeaders = [
+    "accept-encoding",
+    "content-length",
+    "if-modified-since",
+    "if-none-match",
+    "if-range",
+    "if-unmodified-since",
+    "transfer-encoding",
+    "via",
+];
+function normalizeCloudFrontRequestEventHeaders(rawHeaders) {
+    const headers = {};
+    for (const [key, values] of Object.entries(rawHeaders)) {
+        for (const { value } of values) {
+            if (value) {
+                headers[key.toLowerCase()] = value;
+            }
+        }
+    }
+    return headers;
+}
+async function convertFromCloudFrontRequestEvent(event) {
+    const { method, uri, querystring, body, headers, clientIp } = event.Records[0].cf.request;
+    return {
+        type: "core",
+        method,
+        rawPath: uri,
+        url: uri + (querystring ? `?${querystring}` : ""),
+        body: Buffer.from(body?.data ?? "", body?.encoding === "base64" ? "base64" : "utf8"),
+        headers: normalizeCloudFrontRequestEventHeaders(headers),
+        remoteAddress: clientIp,
+        query: convertToQuery(querystring),
+        cookies: headers.cookie?.reduce((acc, cur) => {
+            const { key, value } = cur;
+            return { ...acc, [key ?? ""]: value };
+        }, {}) ?? {},
+    };
+}
+function convertToCloudfrontHeaders(headers, directResponse) {
+    const cloudfrontHeaders = {};
+    Object.entries(headers)
+        .filter(([key]) => !CloudFrontBlacklistedHeaders.some((header) => typeof header === "string" ? header === key : header.test(key)) &&
+        // Only remove read-only headers when directly responding in lambda@edge
+        (directResponse ? !cloudfrontReadOnlyHeaders.includes(key) : true))
+        .forEach(([key, value]) => {
+        if (key === "set-cookie") {
+            const cookies = parseCookies(`${value}`);
+            if (cookies) {
+                cloudfrontHeaders[key] = cookies.map((cookie) => ({
+                    key,
+                    value: cookie,
+                }));
+            }
+            return;
+        }
+        cloudfrontHeaders[key] = [
+            ...(cloudfrontHeaders[key] || []),
+            ...(Array.isArray(value)
+                ? value.map((v) => ({ key, value: v }))
+                : [{ key, value: value.toString() }]),
+        ];
+    });
+    return cloudfrontHeaders;
+}
+async function convertToCloudFrontRequestResult(result, originalRequest) {
+    let responseHeaders = result.type === "middleware"
+        ? result.internalEvent.headers
+        : result.headers;
+    if (result.type === "middleware") {
+        const { method, clientIp, origin } = originalRequest.Records[0].cf.request;
+        // Handle external rewrite
+        if (result.isExternalRewrite) {
+            const serverResponse = createServerResponse(result.internalEvent, {});
+            await proxyRequest(result.internalEvent, serverResponse);
+            const externalResult = convertRes(serverResponse);
+            const body = await fromReadableStream(externalResult.body, externalResult.isBase64Encoded);
+            const cloudfrontResult = {
+                status: externalResult.statusCode.toString(),
+                statusDescription: "OK",
+                headers: convertToCloudfrontHeaders(externalResult.headers, true),
+                bodyEncoding: externalResult.isBase64Encoded
+                    ? "base64"
+                    : "text",
+                body,
+            };
+            debug("externalResult", cloudfrontResult);
+            return cloudfrontResult;
+        }
+        let customOrigin = origin?.custom;
+        let host = responseHeaders["host"] ?? responseHeaders["Host"];
+        if (result.origin) {
+            customOrigin = {
+                ...customOrigin,
+                domainName: result.origin.host,
+                port: result.origin.port ?? 443,
+                protocol: result.origin.protocol ?? "https",
+                customHeaders: {},
+            };
+            host = result.origin.host;
+        }
+        const response = {
+            clientIp,
+            method,
+            uri: result.internalEvent.rawPath,
+            querystring: convertToQueryString(result.internalEvent.query).replace("?", ""),
+            headers: convertToCloudfrontHeaders({
+                ...responseHeaders,
+                host,
+            }),
+            origin: origin?.custom
+                ? {
+                    custom: customOrigin,
+                }
+                : origin,
+        };
+        debug("response rewrite", response);
+        return response;
+    }
+    const body = await fromReadableStream(result.body, result.isBase64Encoded);
+    const response = {
+        status: result.statusCode.toString(),
+        statusDescription: "OK",
+        headers: convertToCloudfrontHeaders(responseHeaders, true),
+        bodyEncoding: result.isBase64Encoded ? "base64" : "text",
+        body,
+    };
+    debug(response);
+    return response;
+}
+export default {
+    convertFrom: convertFromCloudFrontRequestEvent,
+    convertTo: convertToCloudFrontRequestResult,
+    name: "aws-cloudfront",
+};

package/dist/converters/dummy.d.ts

@@ -0,0 +1,7 @@
+import { Converter } from "../types/open-next";
+type DummyEventOrResult = {
+    type: "dummy";
+    original: any;
+};
+declare const converter: Converter<DummyEventOrResult, DummyEventOrResult>;
+export default converter;

package/dist/converters/dummy.js

@@ -0,0 +1,16 @@
+const converter = {
+    convertFrom(event) {
+        return Promise.resolve({
+            type: "dummy",
+            original: event,
+        });
+    },
+    convertTo(internalResult) {
+        return Promise.resolve({
+            type: "dummy",
+            original: internalResult,
+        });
+    },
+    name: "dummy",
+};
+export default converter;

package/dist/converters/edge.d.ts

@@ -0,0 +1,6 @@
+import { Converter, InternalEvent, InternalResult } from "../types/open-next";
+import { MiddlewareOutputEvent } from "../core/routingHandler";
+declare const converter: Converter<InternalEvent, InternalResult | ({
+    type: "middleware";
+} & MiddlewareOutputEvent)>;
+export default converter;

package/dist/converters/edge.js

@@ -0,0 +1,88 @@
+import { Buffer } from "node:buffer";
+import { parseCookies } from "../http/util";
+const converter = {
+    convertFrom: async (event) => {
+        const searchParams = new URL(event.url).searchParams;
+        const query = {};
+        for (const [key, value] of searchParams.entries()) {
+            if (query[key]) {
+                if (Array.isArray(query[key])) {
+                    query[key].push(value);
+                }
+                else {
+                    query[key] = [query[key], value];
+                }
+            }
+            else {
+                query[key] = value;
+            }
+        }
+        //Transform body into Buffer
+        const body = await event.arrayBuffer();
+        const headers = {};
+        event.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const rawPath = new URL(event.url).pathname;
+        const method = event.method;
+        const shouldHaveBody = method !== "GET" && method !== "HEAD";
+        return {
+            type: "core",
+            method,
+            rawPath,
+            url: event.url,
+            body: shouldHaveBody ? Buffer.from(body) : undefined,
+            headers: headers,
+            remoteAddress: event.headers.get("x-forwarded-for") ?? "::1",
+            query,
+            cookies: Object.fromEntries(parseCookies(event.headers.get("cookie") ?? "")?.map((cookie) => {
+                const [key, value] = cookie.split("=");
+                return [key, value];
+            }) ?? []),
+        };
+    },
+    convertTo: async (result) => {
+        if ("internalEvent" in result) {
+            let url = result.internalEvent.url;
+            if (!result.isExternalRewrite) {
+                if (result.origin) {
+                    url = `${result.origin.protocol}://${result.origin.host}${result.origin.port ? `:${result.origin.port}` : ""}${url}`;
+                }
+                else {
+                    url = `https://${result.internalEvent.headers.host}${url}`;
+                }
+            }
+            const req = new Request(url, {
+                body: result.internalEvent.body,
+                method: result.internalEvent.method,
+                headers: {
+                    ...result.internalEvent.headers,
+                    "x-forwarded-host": result.internalEvent.headers.host,
+                },
+            });
+            const cfCache = (result.isISR ||
+                result.internalEvent.rawPath.startsWith("/_next/image")) &&
+                process.env.DISABLE_CACHE !== "true"
+                ? { cacheEverything: true }
+                : {};
+            return fetch(req, {
+                // This is a hack to make sure that the response is cached by Cloudflare
+                // See https://developers.cloudflare.com/workers/examples/cache-using-fetch/#caching-html-resources
+                // @ts-expect-error - This is a Cloudflare specific option
+                cf: cfCache,
+            });
+        }
+        else {
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(result.headers)) {
+                headers.set(key, Array.isArray(value) ? value.join(",") : value);
+            }
+            return new Response(result.body, {
+                status: result.statusCode,
+                headers: headers,
+            });
+        }
+    },
+    name: "edge",
+};
+export default converter;

package/dist/converters/node.d.ts

@@ -0,0 +1,3 @@
+import type { Converter } from "../types/open-next";
+declare const converter: Converter;
+export default converter;

package/dist/converters/node.js

@@ -0,0 +1,45 @@
+import { parseCookies } from "../http/util";
+const converter = {
+    convertFrom: async (req) => {
+        const body = await new Promise((resolve) => {
+            const chunks = [];
+            req.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on("end", () => {
+                resolve(Buffer.concat(chunks));
+            });
+        });
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const query = Object.fromEntries(url.searchParams.entries());
+        return {
+            type: "core",
+            method: req.method ?? "GET",
+            rawPath: url.pathname,
+            url: url.pathname + url.search,
+            body,
+            headers: Object.fromEntries(Object.entries(req.headers ?? {})
+                .map(([key, value]) => [
+                key.toLowerCase(),
+                Array.isArray(value) ? value.join(",") : value,
+            ])
+                .filter(([key]) => key)),
+            remoteAddress: req.headers["x-forwarded-for"] ??
+                req.socket.remoteAddress ??
+                "::1",
+            query,
+            cookies: Object.fromEntries(parseCookies(req.headers["cookie"])?.map((cookie) => {
+                const [key, value] = cookie.split("=");
+                return [key, value];
+            }) ?? []),
+        };
+    },
+    // Nothing to do here, it's streaming
+    convertTo: async (internalResult) => ({
+        body: internalResult.body,
+        headers: internalResult.headers,
+        statusCode: internalResult.statusCode,
+    }),
+    name: "node",
+};
+export default converter;

package/dist/converters/sqs-revalidate.d.ts

@@ -0,0 +1,4 @@
+import { Converter } from "../types/open-next";
+import { RevalidateEvent } from "../adapters/revalidate";
+declare const converter: Converter<RevalidateEvent, RevalidateEvent>;
+export default converter;

package/dist/converters/sqs-revalidate.js

@@ -0,0 +1,22 @@
+const converter = {
+    convertFrom(event) {
+        const records = event.Records.map((record) => {
+            const { host, url } = JSON.parse(record.body);
+            return { host, url, id: record.messageId };
+        });
+        return Promise.resolve({
+            type: "revalidate",
+            records,
+        });
+    },
+    convertTo(revalidateEvent) {
+        return Promise.resolve({
+            type: "revalidate",
+            batchItemFailures: revalidateEvent.records.map((record) => ({
+                itemIdentifier: record.id,
+            })),
+        });
+    },
+    name: "sqs-revalidate",
+};
+export default converter;

package/dist/converters/utils.d.ts

@@ -0,0 +1 @@
+export declare function removeUndefinedFromQuery(query: Record<string, string | string[] | undefined>): Record<string, string | string[]>;

package/dist/converters/utils.js

@@ -0,0 +1,9 @@
+export function removeUndefinedFromQuery(query) {
+    const newQuery = {};
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) {
+            newQuery[key] = value;
+        }
+    }
+    return newQuery;
+}

package/dist/core/createGenericHandler.d.ts

@@ -0,0 +1,11 @@
+import type { BaseEventOrResult, InternalEvent, InternalResult, OpenNextConfig, OpenNextHandler } from "../types/open-next";
+declare global {
+    var openNextConfig: Partial<OpenNextConfig>;
+}
+type HandlerType = "imageOptimization" | "revalidate" | "warmer" | "middleware" | "initializationFunction";
+type GenericHandler<Type extends HandlerType, E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = {
+    handler: OpenNextHandler<E, R>;
+    type: Type;
+};
+export declare function createGenericHandler<Type extends HandlerType, E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(handler: GenericHandler<Type, E, R>): Promise<(...args: any[]) => any>;
+export {};

package/dist/core/createGenericHandler.js

@@ -0,0 +1,16 @@
+import { debug } from "../adapters/logger";
+import { resolveConverter, resolveWrapper } from "./resolve";
+export async function createGenericHandler(handler) {
+    //First we load the config
+    // @ts-expect-error
+    const config = await import("./open-next.config.mjs").then((m) => m.default);
+    globalThis.openNextConfig = config;
+    const override = config[handler.type]
+        ?.override;
+    // From the config, we create the adapter
+    const adapter = await resolveConverter(override?.converter);
+    // Then we create the handler
+    const wrapper = await resolveWrapper(override?.wrapper);
+    debug("Using wrapper", wrapper.name);
+    return wrapper.wrapper(handler.handler, adapter);
+}

package/dist/core/createMainHandler.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import type { AsyncLocalStorage } from "node:async_hooks";
+import { DetachedPromiseRunner } from "../utils/promise";
+import type { IncrementalCache } from "../cache/incremental/types";
+import type { Queue } from "../queue/types";
+declare global {
+    var queue: Queue;
+    var incrementalCache: IncrementalCache;
+    var fnName: string | undefined;
+    var serverId: string;
+    var __als: AsyncLocalStorage<{
+        requestId: string;
+        pendingPromiseRunner: DetachedPromiseRunner;
+        isISRRevalidation?: boolean;
+        mergeHeadersPriority?: "middleware" | "handler";
+    }>;
+}
+export declare function createMainHandler(): Promise<(...args: any[]) => any>;

package/dist/core/createMainHandler.js

@@ -0,0 +1,24 @@
+import { debug } from "../adapters/logger";
+import { generateUniqueId } from "../adapters/util";
+import { openNextHandler } from "./requestHandler.js";
+import { resolveConverter, resolveIncrementalCache, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+export async function createMainHandler() {
+    //First we load the config
+    const config = await import(process.cwd() + "/open-next.config.mjs").then((m) => m.default);
+    const thisFunction = globalThis.fnName
+        ? config.functions[globalThis.fnName]
+        : config.default;
+    globalThis.serverId = generateUniqueId();
+    globalThis.openNextConfig = config;
+    // Default queue
+    globalThis.queue = await resolveQueue(thisFunction.override?.queue);
+    globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
+    globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
+    globalThis.lastModified = {};
+    // From the config, we create the adapter
+    const adapter = await resolveConverter(thisFunction.override?.converter);
+    // Then we create the handler
+    const wrapper = await resolveWrapper(thisFunction.override?.wrapper);
+    debug("Using wrapper", wrapper.name);
+    return wrapper.wrapper(openNextHandler, adapter);
+}

package/dist/core/edgeFunctionHandler.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from "http";
+interface RequestData {
+    geo?: {
+        city?: string;
+        country?: string;
+        region?: string;
+        latitude?: string;
+        longitude?: string;
+    };
+    headers: OutgoingHttpHeaders;
+    ip?: string;
+    method: string;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: any;
+        trailingSlash?: boolean;
+    };
+    page?: {
+        name?: string;
+        params?: {
+            [key: string]: string | string[];
+        };
+    };
+    url: string;
+    body?: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+}
+interface Entries {
+    [k: string]: {
+        default: (props: {
+            page: string;
+            request: RequestData;
+        }) => Promise<{
+            response: Response;
+            waitUntil: Promise<void>;
+        }>;
+    };
+}
+declare global {
+    var _ENTRIES: Entries;
+    var _ROUTES: EdgeRoute[];
+    var __storage__: Map<unknown, unknown>;
+    var AsyncContext: any;
+    var AsyncLocalStorage: any;
+}
+export interface EdgeRoute {
+    name: string;
+    page: string;
+    regex: string[];
+}
+type EdgeRequest = Omit<RequestData, "page">;
+export default function edgeFunctionHandler(request: EdgeRequest): Promise<Response>;
+export {};

package/dist/core/edgeFunctionHandler.js

@@ -0,0 +1,21 @@
+// Necessary files will be imported here with banner in esbuild
+export default async function edgeFunctionHandler(request) {
+    const path = new URL(request.url).pathname;
+    const routes = globalThis._ROUTES;
+    const correspondingRoute = routes.find((route) => route.regex.some((r) => new RegExp(r).test(path)));
+    if (!correspondingRoute) {
+        throw new Error(`No route found for ${request.url}`);
+    }
+    const result = await self._ENTRIES[`middleware_${correspondingRoute.name}`].default({
+        page: correspondingRoute.page,
+        request: {
+            ...request,
+            page: {
+                name: correspondingRoute.name,
+            },
+        },
+    });
+    await result.waitUntil;
+    const response = result.response;
+    return response;
+}

package/dist/core/patchAsyncStorage.d.ts

@@ -0,0 +1 @@
+export declare function patchAsyncStorage(): void;

package/dist/core/patchAsyncStorage.js

@@ -0,0 +1,16 @@
+const mod = require("module");
+const resolveFilename = mod._resolveFilename;
+export function patchAsyncStorage() {
+    mod._resolveFilename = function (originalResolveFilename, request, parent, isMain, options) {
+        if (request.endsWith("static-generation-async-storage.external") ||
+            request.endsWith("static-generation-async-storage.external.js")) {
+            return require.resolve("./patchedAsyncStorage.cjs");
+        }
+        else if (request.endsWith("static-generation-async-storage.external.original")) {
+            return originalResolveFilename.call(mod, request.replace(".original", ".js"), parent, isMain, options);
+        }
+        else
+            return originalResolveFilename.call(mod, request, parent, isMain, options);
+        // We use `bind` here to avoid referencing outside variables to create potential memory leaks.
+    }.bind(null, resolveFilename);
+}

package/dist/core/requestHandler.d.ts

@@ -0,0 +1,3 @@
+import { StreamCreator } from "../http/index.js";
+import { InternalEvent, InternalResult } from "../types/open-next";
+export declare function openNextHandler(internalEvent: InternalEvent, responseStreaming?: StreamCreator): Promise<InternalResult>;