@opennextjs/aws 3.1.4

package/dist/core/routing/i18n/index.js

@@ -0,0 +1,36 @@
+import { NextConfig } from "../../../adapters/config/index.js";
+import { debug } from "../../../adapters/logger.js";
+import { acceptLanguage } from "./accept-header";
+function isLocalizedPath(path) {
+    return (NextConfig.i18n?.locales.includes(path.split("/")[1].toLowerCase()) ?? false);
+}
+// https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/i18n/get-locale-redirect.ts
+function getLocaleFromCookie(cookies) {
+    const i18n = NextConfig.i18n;
+    const nextLocale = cookies.NEXT_LOCALE?.toLowerCase();
+    return nextLocale
+        ? i18n?.locales.find((locale) => nextLocale === locale.toLowerCase())
+        : undefined;
+}
+function detectLocale(internalEvent, i18n) {
+    const cookiesLocale = getLocaleFromCookie(internalEvent.cookies);
+    const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
+    debug({
+        cookiesLocale,
+        preferredLocale,
+        defaultLocale: i18n.defaultLocale,
+    });
+    return cookiesLocale ?? preferredLocale ?? i18n.defaultLocale;
+    // TODO: handle domain based locale detection
+}
+export function localizePath(internalEvent) {
+    const i18n = NextConfig.i18n;
+    if (!i18n) {
+        return internalEvent.rawPath;
+    }
+    if (isLocalizedPath(internalEvent.rawPath)) {
+        return internalEvent.rawPath;
+    }
+    const detectedLocale = detectLocale(internalEvent, i18n);
+    return `/${detectedLocale}${internalEvent.rawPath}`;
+}

package/dist/core/routing/matcher.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
+import { InternalEvent, InternalResult } from "../../types/open-next";
+export declare function addNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
+export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
+    internalEvent: {
+        rawPath: string;
+        url: string;
+        method: string;
+        body?: Buffer | undefined;
+        headers: Record<string, string>;
+        query: Record<string, string | string[]>;
+        cookies: Record<string, string>;
+        remoteAddress: string;
+        type: "core";
+    };
+    __rewrite: T | undefined;
+    isExternalRewrite: boolean;
+};
+export declare function handleRedirects(event: InternalEvent, redirects: RedirectDefinition[]): InternalResult | undefined;
+export declare function fixDataPage(internalEvent: InternalEvent, buildId: string): InternalEvent | InternalResult;
+export declare function handleFallbackFalse(internalEvent: InternalEvent, prerenderManifest: PrerenderManifest): {
+    event: InternalEvent;
+    isISR: boolean;
+};

package/dist/core/routing/matcher.js

@@ -0,0 +1,294 @@
+import { NextConfig } from "../../adapters/config/index";
+import { compile, match, } from "path-to-regexp";
+import { emptyReadableStream, toReadableStream } from "../../utils/stream";
+import { debug } from "../../adapters/logger";
+import { localizePath } from "./i18n";
+import { convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
+const routeHasMatcher = (headers, cookies, query) => (redirect) => {
+    switch (redirect.type) {
+        case "header":
+            return (!!headers?.[redirect.key.toLowerCase()] &&
+                new RegExp(redirect.value ?? "").test(headers[redirect.key.toLowerCase()] ?? ""));
+        case "cookie":
+            return (!!cookies?.[redirect.key] &&
+                new RegExp(redirect.value ?? "").test(cookies[redirect.key] ?? ""));
+        case "query":
+            return query[redirect.key] && Array.isArray(redirect.value)
+                ? redirect.value.reduce((prev, current) => prev || new RegExp(current).test(query[redirect.key]), false)
+                : new RegExp(redirect.value ?? "").test(query[redirect.key] ?? "");
+        case "host":
+            return (headers?.host !== "" &&
+                new RegExp(redirect.value ?? "").test(headers.host));
+        default:
+            return false;
+    }
+};
+function checkHas(matcher, has, inverted = false) {
+    return has
+        ? has.reduce((acc, cur) => {
+            if (acc === false)
+                return false;
+            return inverted ? !matcher(cur) : matcher(cur);
+        }, true)
+        : true;
+}
+const getParamsFromSource = (source) => (value) => {
+    debug("value", value);
+    const _match = source(value);
+    return _match ? _match.params : {};
+};
+const computeParamHas = (headers, cookies, query) => (has) => {
+    if (!has.value)
+        return {};
+    const matcher = new RegExp(`^${has.value}$`);
+    const fromSource = (value) => {
+        const matches = value.match(matcher);
+        return matches?.groups ?? {};
+    };
+    switch (has.type) {
+        case "header":
+            return fromSource(headers[has.key.toLowerCase()] ?? "");
+        case "cookie":
+            return fromSource(cookies[has.key] ?? "");
+        case "query":
+            return Array.isArray(query[has.key])
+                ? fromSource(query[has.key].join(","))
+                : fromSource(query[has.key] ?? "");
+        case "host":
+            return fromSource(headers.host ?? "");
+    }
+};
+function convertMatch(match, toDestination, destination) {
+    if (match) {
+        const { params } = match;
+        const isUsingParams = Object.keys(params).length > 0;
+        if (isUsingParams) {
+            return toDestination(params);
+        }
+        else {
+            return destination;
+        }
+    }
+    else {
+        return destination;
+    }
+}
+export function addNextConfigHeaders(event, configHeaders) {
+    const addedHeaders = {};
+    if (!configHeaders)
+        return addedHeaders;
+    const { rawPath, headers, query, cookies } = event;
+    const matcher = routeHasMatcher(headers, cookies, query);
+    const requestHeaders = {};
+    const localizedRawPath = localizePath(event);
+    for (const { headers, has, missing, regex, source, locale, } of configHeaders) {
+        const path = locale === false ? rawPath : localizedRawPath;
+        if (new RegExp(regex).test(path) &&
+            checkHas(matcher, has) &&
+            checkHas(matcher, missing, true)) {
+            const fromSource = match(source);
+            const _match = fromSource(path);
+            headers.forEach((h) => {
+                try {
+                    const key = convertMatch(_match, compile(h.key), h.key);
+                    const value = convertMatch(_match, compile(h.value), h.value);
+                    requestHeaders[key] = value;
+                }
+                catch {
+                    debug("Error matching header ", h.key, " with value ", h.value);
+                    requestHeaders[h.key] = h.value;
+                }
+            });
+        }
+    }
+    return requestHeaders;
+}
+export function handleRewrites(event, rewrites) {
+    const { rawPath, headers, query, cookies } = event;
+    const localizedRawPath = localizePath(event);
+    const matcher = routeHasMatcher(headers, cookies, query);
+    const computeHas = computeParamHas(headers, cookies, query);
+    const rewrite = rewrites.find((route) => {
+        const path = route.locale === false ? rawPath : localizedRawPath;
+        return (new RegExp(route.regex).test(path) &&
+            checkHas(matcher, route.has) &&
+            checkHas(matcher, route.missing, true));
+    });
+    let finalQuery = query;
+    let rewrittenUrl = rawPath;
+    const isExternalRewrite = isExternal(rewrite?.destination);
+    debug("isExternalRewrite", isExternalRewrite);
+    if (rewrite) {
+        const { pathname, protocol, hostname, queryString } = getUrlParts(rewrite.destination, isExternalRewrite);
+        // We need to use a localized path if the rewrite is not locale specific
+        const pathToUse = rewrite.locale === false ? rawPath : localizedRawPath;
+        debug("urlParts", { pathname, protocol, hostname, queryString });
+        const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
+        const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
+        const toDestinationQuery = compile(escapeRegex(queryString ?? "") ?? "");
+        let params = {
+            // params for the source
+            ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
+            // params for the has
+            ...rewrite.has?.reduce((acc, cur) => {
+                return { ...acc, ...computeHas(cur) };
+            }, {}),
+            // params for the missing
+            ...rewrite.missing?.reduce((acc, cur) => {
+                return { ...acc, ...computeHas(cur) };
+            }, {}),
+        };
+        const isUsingParams = Object.keys(params).length > 0;
+        let rewrittenQuery = queryString;
+        let rewrittenHost = hostname;
+        let rewrittenPath = pathname;
+        if (isUsingParams) {
+            rewrittenPath = unescapeRegex(toDestinationPath(params));
+            rewrittenHost = unescapeRegex(toDestinationHost(params));
+            rewrittenQuery = unescapeRegex(toDestinationQuery(params));
+        }
+        rewrittenUrl = isExternalRewrite
+            ? `${protocol}//${rewrittenHost}${rewrittenPath}`
+            : `/${rewrittenPath}`;
+        // Should we merge the query params or use only the ones from the rewrite?
+        finalQuery = {
+            ...query,
+            ...convertFromQueryString(rewrittenQuery),
+        };
+        debug("rewrittenUrl", { rewrittenUrl, finalQuery, isUsingParams });
+    }
+    return {
+        internalEvent: {
+            ...event,
+            rawPath: rewrittenUrl,
+            url: `${rewrittenUrl}${convertToQueryString(finalQuery)}`,
+        },
+        __rewrite: rewrite,
+        isExternalRewrite,
+    };
+}
+function handleTrailingSlashRedirect(event) {
+    const url = new URL(event.url, "http://localhost");
+    const emptyBody = emptyReadableStream();
+    if (
+    // Someone is trying to redirect to a different origin, let's not do that
+    url.host !== "localhost" ||
+        NextConfig.skipTrailingSlashRedirect ||
+        // We should not apply trailing slash redirect to API routes
+        event.rawPath.startsWith("/api/")) {
+        return false;
+    }
+    if (NextConfig.trailingSlash &&
+        !event.headers["x-nextjs-data"] &&
+        !event.rawPath.endsWith("/") &&
+        !event.rawPath.match(/[\w-]+\.[\w]+$/g)) {
+        const headersLocation = event.url.split("?");
+        return {
+            type: event.type,
+            statusCode: 308,
+            headers: {
+                Location: `${headersLocation[0]}/${headersLocation[1] ? `?${headersLocation[1]}` : ""}`,
+            },
+            body: emptyBody,
+            isBase64Encoded: false,
+        };
+        // eslint-disable-next-line sonarjs/elseif-without-else
+    }
+    else if (!NextConfig.trailingSlash &&
+        event.rawPath.endsWith("/") &&
+        event.rawPath !== "/") {
+        const headersLocation = event.url.split("?");
+        return {
+            type: event.type,
+            statusCode: 308,
+            headers: {
+                Location: `${headersLocation[0].replace(/\/$/, "")}${headersLocation[1] ? `?${headersLocation[1]}` : ""}`,
+            },
+            body: emptyBody,
+            isBase64Encoded: false,
+        };
+    }
+    else
+        return false;
+}
+export function handleRedirects(event, redirects) {
+    const trailingSlashRedirect = handleTrailingSlashRedirect(event);
+    if (trailingSlashRedirect)
+        return trailingSlashRedirect;
+    const { internalEvent, __rewrite } = handleRewrites(event, redirects.filter((r) => !r.internal));
+    if (__rewrite && !__rewrite.internal) {
+        return {
+            type: event.type,
+            statusCode: __rewrite.statusCode ?? 308,
+            headers: {
+                Location: internalEvent.url,
+            },
+            body: emptyReadableStream(),
+            isBase64Encoded: false,
+        };
+    }
+}
+export function fixDataPage(internalEvent, buildId) {
+    const { rawPath, query } = internalEvent;
+    const dataPattern = `/_next/data/${buildId}`;
+    // Return 404 for data requests that don't match the buildId
+    if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
+        return {
+            type: internalEvent.type,
+            statusCode: 404,
+            body: toReadableStream("{}"),
+            headers: {
+                "Content-Type": "application/json",
+            },
+            isBase64Encoded: false,
+        };
+    }
+    if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
+        let newPath = rawPath.replace(dataPattern, "").replace(/\.json$/, "");
+        newPath = newPath === "/index" ? "/" : newPath;
+        query.__nextDataReq = "1";
+        return {
+            ...internalEvent,
+            rawPath: newPath,
+            query,
+            url: `${newPath}${convertToQueryString(query)}`,
+        };
+    }
+    return internalEvent;
+}
+export function handleFallbackFalse(internalEvent, prerenderManifest) {
+    const { rawPath } = internalEvent;
+    const { dynamicRoutes, routes } = prerenderManifest;
+    const routeFallback = Object.entries(dynamicRoutes)
+        .filter(([, { fallback }]) => fallback === false)
+        .some(([, { routeRegex }]) => {
+        const routeRegexExp = new RegExp(routeRegex);
+        return routeRegexExp.test(rawPath);
+    });
+    const locales = NextConfig.i18n?.locales;
+    const routesAlreadyHaveLocale = (locales !== undefined && locales.includes(rawPath.split("/")[1])) ||
+        // If we don't use locales, we don't need to add the default locale
+        locales === undefined;
+    const localizedPath = routesAlreadyHaveLocale
+        ? rawPath
+        : `/${NextConfig.i18n?.defaultLocale}${rawPath}`;
+    const isPregenerated = Object.keys(routes).includes(localizedPath);
+    if (routeFallback && !isPregenerated) {
+        return {
+            event: {
+                ...internalEvent,
+                rawPath: "/404",
+                url: "/404",
+                headers: {
+                    ...internalEvent.headers,
+                    "x-invoke-status": "404",
+                },
+            },
+            isISR: false,
+        };
+    }
+    return {
+        event: internalEvent,
+        isISR: routeFallback || isPregenerated,
+    };
+}

package/dist/core/routing/middleware.d.ts

@@ -0,0 +1,7 @@
+import { InternalEvent, InternalResult } from "../../types/open-next.js";
+type MiddlewareOutputEvent = InternalEvent & {
+    responseHeaders?: Record<string, string | string[]>;
+    externalRewrite?: boolean;
+};
+export declare function handleMiddleware(internalEvent: InternalEvent): Promise<MiddlewareOutputEvent | InternalResult>;
+export {};

package/dist/core/routing/middleware.js

@@ -0,0 +1,167 @@
+import { MiddlewareManifest, NextConfig } from "../../adapters/config/index.js";
+import { emptyReadableStream } from "../../utils/stream.js";
+import { localizePath } from "./i18n/index.js";
+//NOTE: we should try to avoid importing stuff from next as much as possible
+// every release of next could break this
+// const { run } = require("next/dist/server/web/sandbox");
+// const { getCloneableBody } = require("next/dist/server/body-streams");
+// const {
+//   signalFromNodeResponse,
+// } = require("next/dist/server/web/spec-extension/adapters/next-request");
+import { convertBodyToReadableStream, convertToQueryString, getMiddlewareMatch, isExternal, } from "./util.js";
+const middlewareManifest = MiddlewareManifest;
+const middleMatch = getMiddlewareMatch(middlewareManifest);
+// NOTE: As of Nextjs 13.4.13+, the middleware is handled outside the next-server.
+// OpenNext will run the middleware in a sandbox and set the appropriate req headers
+// and res.body prior to processing the next-server.
+// @returns undefined | res.end()
+//    if res.end() is return, the parent needs to return and not process next server
+export async function handleMiddleware(internalEvent) {
+    const { query } = internalEvent;
+    const normalizedPath = localizePath(internalEvent);
+    // We only need the normalizedPath to check if the middleware should run
+    const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
+    if (!hasMatch)
+        return internalEvent;
+    // We bypass the middleware if the request is internal
+    if (internalEvent.headers["x-isr"])
+        return internalEvent;
+    const host = internalEvent.headers.host
+        ? `https://${internalEvent.headers.host}`
+        : "http://localhost:3000";
+    const initialUrl = new URL(normalizedPath, host);
+    initialUrl.search = convertToQueryString(query);
+    const url = initialUrl.toString();
+    // console.log("url", url, normalizedPath);
+    // @ts-expect-error - This is bundled
+    const middleware = await import("./middleware.mjs");
+    const result = await middleware.default({
+        geo: {
+            city: internalEvent.headers["x-open-next-city"],
+            country: internalEvent.headers["x-open-next-country"],
+            region: internalEvent.headers["x-open-next-region"],
+            latitude: internalEvent.headers["x-open-next-latitude"],
+            longitude: internalEvent.headers["x-open-next-longitude"],
+        },
+        headers: internalEvent.headers,
+        method: internalEvent.method || "GET",
+        nextConfig: {
+            basePath: NextConfig.basePath,
+            i18n: NextConfig.i18n,
+            trailingSlash: NextConfig.trailingSlash,
+        },
+        url,
+        body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
+    });
+    const statusCode = result.status;
+    /* Apply override headers from middleware
+      NextResponse.next({
+        request: {
+          headers: new Headers(request.headers),
+        }
+      })
+      Nextjs will set `x-middleware-override-headers` as a comma separated list of keys.
+      All the keys will be prefixed with `x-middleware-request-<key>`
+  
+      We can delete `x-middleware-override-headers` and check if the key starts with
+      x-middleware-request- to set the req headers
+    */
+    const responseHeaders = result.headers;
+    const reqHeaders = {};
+    const resHeaders = {};
+    responseHeaders.delete("x-middleware-override-headers");
+    const xMiddlewareKey = "x-middleware-request-";
+    responseHeaders.forEach((value, key) => {
+        if (key.startsWith(xMiddlewareKey)) {
+            const k = key.substring(xMiddlewareKey.length);
+            reqHeaders[k] = value;
+        }
+        else {
+            if (key.toLowerCase() === "set-cookie") {
+                resHeaders[key] = resHeaders[key]
+                    ? [...resHeaders[key], value]
+                    : [value];
+            }
+            else {
+                resHeaders[key] = value;
+            }
+        }
+    });
+    // If the middleware returned a Redirect, we set the `Location` header with
+    // the redirected url and end the response.
+    if (statusCode >= 300 && statusCode < 400) {
+        resHeaders.location =
+            responseHeaders
+                .get("location")
+                ?.replace("http://localhost:3000", `https://${internalEvent.headers.host}`) ?? resHeaders.location;
+        // res.setHeader("Location", location);
+        return {
+            body: emptyReadableStream(),
+            type: internalEvent.type,
+            statusCode: statusCode,
+            headers: resHeaders,
+            isBase64Encoded: false,
+        };
+    }
+    // If the middleware returned a Rewrite, set the `url` to the pathname of the rewrite
+    // NOTE: the header was added to `req` from above
+    const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
+    let rewritten = false;
+    let externalRewrite = false;
+    let middlewareQueryString = internalEvent.query;
+    let newUrl = internalEvent.url;
+    if (rewriteUrl) {
+        // If not a string, it should probably throw
+        if (isExternal(rewriteUrl, internalEvent.headers.host)) {
+            newUrl = rewriteUrl;
+            rewritten = true;
+            externalRewrite = true;
+        }
+        else {
+            const rewriteUrlObject = new URL(rewriteUrl);
+            newUrl = rewriteUrlObject.pathname;
+            // Reset the query params if the middleware is a rewrite
+            if (middlewareQueryString["__nextDataReq"]) {
+                middlewareQueryString = {
+                    __nextDataReq: middlewareQueryString["__nextDataReq"],
+                };
+            }
+            else {
+                middlewareQueryString = {};
+            }
+            rewriteUrlObject.searchParams.forEach((v, k) => {
+                middlewareQueryString[k] = v;
+            });
+            rewritten = true;
+        }
+    }
+    // If the middleware returned a `NextResponse`, pipe the body to res. This will return
+    // the body immediately to the client.
+    if (result.body) {
+        // transfer response body to res
+        const body = result.body;
+        // await pipeReadable(result.response.body, res);
+        return {
+            type: internalEvent.type,
+            statusCode: statusCode,
+            headers: resHeaders,
+            body,
+            isBase64Encoded: false,
+        };
+    }
+    return {
+        responseHeaders: resHeaders,
+        url: newUrl,
+        rawPath: rewritten
+            ? newUrl ?? internalEvent.rawPath
+            : internalEvent.rawPath,
+        type: internalEvent.type,
+        headers: { ...internalEvent.headers, ...reqHeaders },
+        body: internalEvent.body,
+        method: internalEvent.method,
+        query: middlewareQueryString,
+        cookies: internalEvent.cookies,
+        remoteAddress: internalEvent.remoteAddress,
+        externalRewrite,
+    };
+}

package/dist/core/routing/util.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { OutgoingHttpHeaders } from "node:http";
+import type { IncomingMessage, StreamCreator } from "../../http/index.js";
+import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
+import type { MiddlewareManifest } from "../../types/next-types";
+import { InternalEvent, InternalResult } from "../../types/open-next.js";
+/**
+ *
+ * @__PURE__
+ */
+export declare function isExternal(url?: string, host?: string): boolean;
+export declare function convertFromQueryString(query: string): Record<string, string>;
+/**
+ *
+ * @__PURE__
+ */
+export declare function getUrlParts(url: string, isExternal: boolean): {
+    hostname: string;
+    pathname: string;
+    protocol: string;
+    queryString: string;
+};
+/**
+ *
+ * @__PURE__
+ */
+export declare function convertRes(res: OpenNextNodeResponse): InternalResult;
+/**
+ * Make sure that multi-value query parameters are transformed to
+ * ?key=value1&key=value2&... so that Next converts those parameters
+ * to an array when reading the query parameters
+ * @__PURE__
+ */
+export declare function convertToQueryString(query: Record<string, string | string[]>): string;
+/**
+ * Given a raw query string, returns a record with key value-array pairs
+ * similar to how multiValueQueryStringParameters are structured
+ * @__PURE__
+ */
+export declare function convertToQuery(querystring: string): Record<string, string | string[]>;
+/**
+ *
+ * @__PURE__
+ */
+export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifest): RegExp[];
+/**
+ *
+ * @__PURE__
+ */
+export declare function escapeRegex(str: string): string;
+/**
+ *
+ * @__PURE__
+ */
+export declare function unescapeRegex(str: string): string;
+/**
+ * @__PURE__
+ */
+export declare function convertBodyToReadableStream(method: string, body?: string | Buffer): ReadableStream<any> | undefined;
+/**
+ *
+ * @__PURE__
+ */
+export declare function proxyRequest(internalEvent: InternalEvent, res: OpenNextNodeResponse): Promise<void>;
+declare global {
+    var openNextDebug: boolean;
+    var openNextVersion: string;
+    var lastModified: Record<string, number>;
+}
+/**
+ *
+ * @__PURE__
+ */
+export declare function fixCacheHeaderForHtmlPages(rawPath: string, headers: OutgoingHttpHeaders): void;
+/**
+ *
+ * @__PURE__
+ */
+export declare function fixSWRCacheHeader(headers: OutgoingHttpHeaders): void;
+/**
+ *
+ * @__PURE__
+ */
+export declare function addOpenNextHeader(headers: OutgoingHttpHeaders): void;
+/**
+ *
+ * @__PURE__
+ */
+export declare function revalidateIfRequired(host: string, rawPath: string, headers: OutgoingHttpHeaders, req?: IncomingMessage): Promise<void>;
+export declare function generateMessageGroupId(rawPath: string): string;
+/**
+ *
+ * @__PURE__
+ */
+export declare function fixISRHeaders(headers: OutgoingHttpHeaders): void;
+/**
+ *
+ * @param internalEvent
+ * @param headers
+ * @param responseStream
+ * @returns
+ * @__PURE__
+ */
+export declare function createServerResponse(internalEvent: InternalEvent, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;