@opennextjs/aws 3.1.4

package/dist/core/routing/util.js

@@ -0,0 +1,415 @@
+import crypto from "node:crypto";
+import { Readable } from "node:stream";
+import { BuildId, HtmlPages } from "../../adapters/config/index.js";
+import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
+import { parseHeaders } from "../../http/util.js";
+import { isBinaryContentType } from "../../adapters/binary.js";
+import { debug, error } from "../../adapters/logger.js";
+/**
+ *
+ * @__PURE__
+ */
+export function isExternal(url, host) {
+    if (!url)
+        return false;
+    const pattern = /^https?:\/\//;
+    if (host) {
+        return pattern.test(url) && !url.includes(host);
+    }
+    return pattern.test(url);
+}
+export function convertFromQueryString(query) {
+    if (query === "")
+        return {};
+    const queryParts = query.split("&");
+    return queryParts.reduce((acc, part) => {
+        const [key, value] = part.split("=");
+        return { ...acc, [key]: value };
+    }, {});
+}
+/**
+ *
+ * @__PURE__
+ */
+export function getUrlParts(url, isExternal) {
+    if (!isExternal) {
+        const regex = /\/([^?]*)\??(.*)/;
+        const match = url.match(regex);
+        return {
+            hostname: "",
+            pathname: match?.[1] ?? url,
+            protocol: "",
+            queryString: match?.[2] ?? "",
+        };
+    }
+    const regex = /^(https?:)\/\/?([^\/\s]+)(\/[^?]*)?(\?.*)?/;
+    const match = url.match(regex);
+    if (!match) {
+        throw new Error(`Invalid external URL: ${url}`);
+    }
+    return {
+        protocol: match[1] ?? "https:",
+        hostname: match[2],
+        pathname: match[3],
+        queryString: match[4]?.slice(1) ?? "",
+    };
+}
+/**
+ *
+ * @__PURE__
+ */
+export function convertRes(res) {
+    // Format Next.js response to Lambda response
+    const statusCode = res.statusCode || 200;
+    // When using HEAD requests, it seems that flushHeaders is not called, not sure why
+    // Probably some kind of race condition
+    const headers = parseHeaders(res.getFixedHeaders());
+    const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
+        !!headers["content-encoding"];
+    // We cannot convert the OpenNextNodeResponse to a ReadableStream directly
+    // You can look in the `aws-lambda.ts` file for some context
+    const body = Readable.toWeb(Readable.from(res.getBody()));
+    return {
+        type: "core",
+        statusCode,
+        headers,
+        body,
+        isBase64Encoded,
+    };
+}
+/**
+ * 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 function convertToQueryString(query) {
+    const urlQuery = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            value.forEach((entry) => urlQuery.append(key, entry));
+        }
+        else {
+            urlQuery.append(key, value);
+        }
+    });
+    const queryString = urlQuery.toString();
+    return queryString ? `?${queryString}` : "";
+}
+/**
+ * Given a raw query string, returns a record with key value-array pairs
+ * similar to how multiValueQueryStringParameters are structured
+ * @__PURE__
+ */
+export function convertToQuery(querystring) {
+    const query = new URLSearchParams(querystring);
+    const queryObject = {};
+    for (const key of query.keys()) {
+        const queries = query.getAll(key);
+        queryObject[key] = queries.length > 1 ? queries : queries[0];
+    }
+    return queryObject;
+}
+/**
+ *
+ * @__PURE__
+ */
+export function getMiddlewareMatch(middlewareManifest) {
+    const rootMiddleware = middlewareManifest.middleware["/"];
+    if (!rootMiddleware?.matchers)
+        return [];
+    return rootMiddleware.matchers.map(({ regexp }) => new RegExp(regexp));
+}
+/**
+ *
+ * @__PURE__
+ */
+export function escapeRegex(str) {
+    let path = str.replace(/\(\.\)/g, "_µ1_");
+    path = path.replace(/\(\.{2}\)/g, "_µ2_");
+    path = path.replace(/\(\.{3}\)/g, "_µ3_");
+    return path;
+}
+/**
+ *
+ * @__PURE__
+ */
+export function unescapeRegex(str) {
+    let path = str.replace(/_µ1_/g, "(.)");
+    path = path.replace(/_µ2_/g, "(..)");
+    path = path.replace(/_µ3_/g, "(...)");
+    return path;
+}
+/**
+ *
+ * @__PURE__
+ */
+function filterHeadersForProxy(headers) {
+    const filteredHeaders = {};
+    const disallowedHeaders = [
+        "host",
+        "connection",
+        "via",
+        "x-cache",
+        "transfer-encoding",
+        "content-encoding",
+        "content-length",
+    ];
+    Object.entries(headers).forEach(([key, value]) => {
+        const lowerKey = key.toLowerCase();
+        if (disallowedHeaders.includes(lowerKey) || lowerKey.startsWith("x-amz"))
+            return;
+        else {
+            filteredHeaders[key] = value?.toString() ?? "";
+        }
+    });
+    return filteredHeaders;
+}
+/**
+ * @__PURE__
+ */
+export function convertBodyToReadableStream(method, body) {
+    if (method === "GET" || method === "HEAD")
+        return undefined;
+    if (!body)
+        return undefined;
+    const readable = new ReadableStream({
+        start(controller) {
+            controller.enqueue(body);
+            controller.close();
+        },
+    });
+    return readable;
+}
+/**
+ *
+ * @__PURE__
+ */
+export async function proxyRequest(internalEvent, res) {
+    const { url, headers, method, body } = internalEvent;
+    const request = await import("node:https").then((m) => m.request);
+    debug("proxyRequest", url);
+    await new Promise((resolve, reject) => {
+        const filteredHeaders = filterHeadersForProxy(headers);
+        debug("filteredHeaders", filteredHeaders);
+        const req = request(url, {
+            headers: filteredHeaders,
+            method,
+            rejectUnauthorized: false,
+        }, (_res) => {
+            res.writeHead(_res.statusCode ?? 200, filterHeadersForProxy(_res.headers));
+            if (_res.headers["content-encoding"] === "br") {
+                _res.pipe(require("node:zlib").createBrotliDecompress()).pipe(res);
+            }
+            else if (_res.headers["content-encoding"] === "gzip") {
+                _res.pipe(require("node:zlib").createGunzip()).pipe(res);
+            }
+            else {
+                _res.pipe(res);
+            }
+            _res.on("error", (e) => {
+                error("proxyRequest error", e);
+                res.end();
+                reject(e);
+            });
+            _res.on("end", () => {
+                resolve();
+            });
+        });
+        if (body && method !== "GET" && method !== "HEAD") {
+            req.write(body);
+        }
+        req.end();
+    });
+    // console.log("result", result);
+    // res.writeHead(result.status, resHeaders);
+    // res.end(await result.text());
+}
+var CommonHeaders;
+(function (CommonHeaders) {
+    CommonHeaders["CACHE_CONTROL"] = "cache-control";
+    CommonHeaders["NEXT_CACHE"] = "x-nextjs-cache";
+})(CommonHeaders || (CommonHeaders = {}));
+/**
+ *
+ * @__PURE__
+ */
+export function fixCacheHeaderForHtmlPages(rawPath, headers) {
+    // We don't want to cache error pages
+    if (rawPath === "/404" || rawPath === "/500") {
+        headers[CommonHeaders.CACHE_CONTROL] =
+            "private, no-cache, no-store, max-age=0, must-revalidate";
+        return;
+    }
+    // WORKAROUND: `NextServer` does not set cache headers for HTML pages — https://github.com/serverless-stack/open-next#workaround-nextserver-does-not-set-cache-headers-for-html-pages
+    if (HtmlPages.includes(rawPath)) {
+        headers[CommonHeaders.CACHE_CONTROL] =
+            "public, max-age=0, s-maxage=31536000, must-revalidate";
+    }
+}
+/**
+ *
+ * @__PURE__
+ */
+export function fixSWRCacheHeader(headers) {
+    // WORKAROUND: `NextServer` does not set correct SWR cache headers — https://github.com/sst/open-next#workaround-nextserver-does-not-set-correct-swr-cache-headers
+    let cacheControl = headers[CommonHeaders.CACHE_CONTROL];
+    if (!cacheControl)
+        return;
+    if (Array.isArray(cacheControl)) {
+        cacheControl = cacheControl.join(",");
+    }
+    if (typeof cacheControl !== "string")
+        return;
+    headers[CommonHeaders.CACHE_CONTROL] = cacheControl.replace(/\bstale-while-revalidate(?!=)/, "stale-while-revalidate=2592000");
+}
+/**
+ *
+ * @__PURE__
+ */
+export function addOpenNextHeader(headers) {
+    headers["X-OpenNext"] = "1";
+    if (globalThis.openNextDebug) {
+        headers["X-OpenNext-Version"] = globalThis.openNextVersion;
+        headers["X-OpenNext-RequestId"] = globalThis.__als.getStore()?.requestId;
+    }
+}
+/**
+ *
+ * @__PURE__
+ */
+export async function revalidateIfRequired(host, rawPath, headers, req) {
+    if (headers[CommonHeaders.NEXT_CACHE] === "STALE") {
+        // If the URL is rewritten, revalidation needs to be done on the rewritten URL.
+        // - Link to Next.js doc: https://nextjs.org/docs/pages/building-your-application/data-fetching/incremental-static-regeneration#on-demand-revalidation
+        // - Link to NextInternalRequestMeta: https://github.com/vercel/next.js/blob/57ab2818b93627e91c937a130fb56a36c41629c3/packages/next/src/server/request-meta.ts#L11
+        // @ts-ignore
+        const internalMeta = req?.[Symbol.for("NextInternalRequestMeta")];
+        // When using Pages Router, two requests will be received:
+        // 1. one for the page: /foo
+        // 2. one for the json data: /_next/data/BUILD_ID/foo.json
+        // The rewritten url is correct for 1, but that for the second request
+        // does not include the "/_next/data/" prefix. Need to add it.
+        const revalidateUrl = internalMeta?._nextDidRewrite
+            ? rawPath.startsWith("/_next/data/")
+                ? `/_next/data/${BuildId}${internalMeta?._nextRewroteUrl}.json`
+                : internalMeta?._nextRewroteUrl
+            : rawPath;
+        // We need to pass etag to the revalidation queue to try to bypass the default 5 min deduplication window.
+        // https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagededuplicationid-property.html
+        // If you need to have a revalidation happen more frequently than 5 minutes,
+        // your page will need to have a different etag to bypass the deduplication window.
+        // If data has the same etag during these 5 min dedup window, it will be deduplicated and not revalidated.
+        try {
+            const hash = (str) => crypto.createHash("md5").update(str).digest("hex");
+            const requestId = globalThis.__als.getStore()?.requestId ?? "";
+            const lastModified = globalThis.lastModified[requestId] > 0
+                ? globalThis.lastModified[requestId]
+                : "";
+            // For some weird cases, lastModified is not set, haven't been able to figure out yet why
+            // For those cases we add the etag to the deduplication id, it might help
+            const etag = headers["etag"] ?? headers["ETag"] ?? "";
+            await globalThis.queue.send({
+                MessageBody: { host, url: revalidateUrl },
+                MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${etag}`),
+                MessageGroupId: generateMessageGroupId(rawPath),
+            });
+        }
+        catch (e) {
+            error(`Failed to revalidate stale page ${rawPath}`, e);
+        }
+    }
+}
+// Since we're using a FIFO queue, every messageGroupId is treated sequentially
+// This could cause a backlog of messages in the queue if there is too much page to
+// revalidate at once. To avoid this, we generate a random messageGroupId for each
+// revalidation request.
+// We can't just use a random string because we need to ensure that the same rawPath
+// will always have the same messageGroupId.
+// https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript#answer-47593316
+export function generateMessageGroupId(rawPath) {
+    let a = cyrb128(rawPath);
+    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    var t = (a += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    // This will generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    // This means that we could have 1000 revalidate request at the same time
+    const maxConcurrency = parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
+    const randomInt = Math.floor(randomFloat * maxConcurrency);
+    return `revalidate-${randomInt}`;
+}
+// Used to generate a hash int from a string
+function cyrb128(str) {
+    let h1 = 1779033703, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
+    for (let i = 0, k; i < str.length; i++) {
+        k = str.charCodeAt(i);
+        h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+        h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+        h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+        h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+    }
+    h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
+    h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
+    h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
+    h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
+    (h1 ^= h2 ^ h3 ^ h4), (h2 ^= h1), (h3 ^= h1), (h4 ^= h1);
+    return h1 >>> 0;
+}
+/**
+ *
+ * @__PURE__
+ */
+export function fixISRHeaders(headers) {
+    if (headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
+        headers[CommonHeaders.CACHE_CONTROL] =
+            "private, no-cache, no-store, max-age=0, must-revalidate";
+        return;
+    }
+    const requestId = globalThis.__als.getStore()?.requestId ?? "";
+    const _lastModified = globalThis.lastModified[requestId] ?? 0;
+    if (headers[CommonHeaders.NEXT_CACHE] === "HIT" && _lastModified > 0) {
+        // calculate age
+        const age = Math.round((Date.now() - _lastModified) / 1000);
+        // extract s-maxage from cache-control
+        const regex = /s-maxage=(\d+)/;
+        const cacheControl = headers[CommonHeaders.CACHE_CONTROL];
+        debug("cache-control", cacheControl, globalThis.lastModified, Date.now());
+        if (typeof cacheControl !== "string")
+            return;
+        const match = cacheControl.match(regex);
+        const sMaxAge = match ? parseInt(match[1]) : undefined;
+        // 31536000 is the default s-maxage value for SSG pages
+        if (sMaxAge && sMaxAge !== 31536000) {
+            const remainingTtl = Math.max(sMaxAge - age, 1);
+            headers[CommonHeaders.CACHE_CONTROL] = `s-maxage=${remainingTtl}, stale-while-revalidate=2592000`;
+        }
+    }
+    if (headers[CommonHeaders.NEXT_CACHE] !== "STALE")
+        return;
+    // If the cache is stale, we revalidate in the background
+    // In order for CloudFront SWR to work, we set the stale-while-revalidate value to 2 seconds
+    // This will cause CloudFront to cache the stale data for a short period of time while we revalidate in the background
+    // Once the revalidation is complete, CloudFront will serve the fresh data
+    headers[CommonHeaders.CACHE_CONTROL] =
+        "s-maxage=2, stale-while-revalidate=2592000";
+}
+/**
+ *
+ * @param internalEvent
+ * @param headers
+ * @param responseStream
+ * @returns
+ * @__PURE__
+ */
+export function createServerResponse(internalEvent, headers, responseStream) {
+    return new OpenNextNodeResponse((_headers) => {
+        fixCacheHeaderForHtmlPages(internalEvent.rawPath, _headers);
+        fixSWRCacheHeader(_headers);
+        addOpenNextHeader(_headers);
+        fixISRHeaders(_headers);
+    }, async (_headers) => {
+        await revalidateIfRequired(internalEvent.headers.host, internalEvent.rawPath, _headers);
+    }, responseStream, headers);
+}

package/dist/core/routingHandler.d.ts

@@ -0,0 +1,8 @@
+import { InternalEvent, InternalResult, Origin } from "../types/open-next";
+export interface MiddlewareOutputEvent {
+    internalEvent: InternalEvent;
+    isExternalRewrite: boolean;
+    origin: Origin | false;
+    isISR: boolean;
+}
+export default function routingHandler(event: InternalEvent): Promise<InternalResult | MiddlewareOutputEvent>;

package/dist/core/routingHandler.js

@@ -0,0 +1,127 @@
+import { BuildId, ConfigHeaders, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
+import { debug } from "../adapters/logger";
+import { cacheInterceptor } from "./routing/cacheInterceptor";
+import { addNextConfigHeaders, fixDataPage, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
+import { handleMiddleware } from "./routing/middleware";
+// Add the locale prefix to the regex so we correctly match the rawPath
+const optionalLocalePrefixRegex = !!RoutesManifest.locales.length
+    ? `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`
+    : "^/";
+// Add the basepath prefix to the regex so we correctly match the rawPath
+const optionalBasepathPrefixRegex = !!RoutesManifest.basePath
+    ? `^${RoutesManifest.basePath}/?`
+    : "^/";
+// Add the basePath prefix to the api routes
+const apiPrefix = !!RoutesManifest.basePath
+    ? `${RoutesManifest.basePath}/api`
+    : "/api";
+const staticRegexp = RoutesManifest.routes.static.map((route) => new RegExp(route.regex
+    .replace("^/", optionalLocalePrefixRegex)
+    .replace("^/", optionalBasepathPrefixRegex)));
+const dynamicRegexp = RoutesManifest.routes.dynamic.map((route) => new RegExp(route.regex
+    .replace("^/", optionalLocalePrefixRegex)
+    .replace("^/", optionalBasepathPrefixRegex)));
+function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = true) {
+    Object.entries(middlewareHeaders).forEach(([key, value]) => {
+        if (value) {
+            eventHeaders[`${setPrefix ? "x-middleware-response-" : ""}${key}`] =
+                Array.isArray(value) ? value.join(",") : value;
+        }
+    });
+}
+export default async function routingHandler(event) {
+    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders) ?? {};
+    let internalEvent = fixDataPage(event, BuildId);
+    if ("statusCode" in internalEvent) {
+        return internalEvent;
+    }
+    const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
+    if (redirect) {
+        debug("redirect", redirect);
+        return redirect;
+    }
+    const middleware = await handleMiddleware(internalEvent);
+    let middlewareResponseHeaders = {};
+    if ("statusCode" in middleware) {
+        return middleware;
+    }
+    else {
+        middlewareResponseHeaders = middleware.responseHeaders || {};
+        internalEvent = middleware;
+    }
+    // At this point internalEvent is an InternalEvent or a MiddlewareOutputEvent
+    let isExternalRewrite = middleware.externalRewrite ?? false;
+    if (!isExternalRewrite) {
+        // First rewrite to be applied
+        const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
+        internalEvent = beforeRewrites.internalEvent;
+        isExternalRewrite = beforeRewrites.isExternalRewrite;
+    }
+    const isStaticRoute = !isExternalRewrite &&
+        staticRegexp.some((route) => route.test(internalEvent.rawPath));
+    if (!isStaticRoute && !isExternalRewrite) {
+        // Second rewrite to be applied
+        const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
+        internalEvent = afterRewrites.internalEvent;
+        isExternalRewrite = afterRewrites.isExternalRewrite;
+    }
+    // We want to run this just before the dynamic route check
+    const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
+    internalEvent = fallbackEvent;
+    const isDynamicRoute = !isExternalRewrite &&
+        dynamicRegexp.some((route) => route.test(internalEvent.rawPath));
+    if (!isDynamicRoute && !isStaticRoute && !isExternalRewrite) {
+        // Fallback rewrite to be applied
+        const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
+        internalEvent = fallbackRewrites.internalEvent;
+        isExternalRewrite = fallbackRewrites.isExternalRewrite;
+    }
+    // Api routes are not present in the routes manifest except if they're not behind /api
+    // /api even if it's a page route doesn't get generated in the manifest
+    // Ideally we would need to properly check api routes here
+    const isApiRoute = internalEvent.rawPath === apiPrefix ||
+        internalEvent.rawPath.startsWith(`${apiPrefix}/`);
+    const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
+    const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
+    // If we still haven't found a route, we show the 404 page
+    // We need to ensure that rewrites are applied before showing the 404 page
+    if (!isRouteFoundBeforeAllRewrites &&
+        !isApiRoute &&
+        !isNextImageRoute &&
+        // We need to check again once all rewrites have been applied
+        !staticRegexp.some((route) => route.test(internalEvent.rawPath)) &&
+        !dynamicRegexp.some((route) => route.test(internalEvent.rawPath))) {
+        internalEvent = {
+            ...internalEvent,
+            rawPath: "/404",
+            url: "/404",
+            headers: {
+                ...internalEvent.headers,
+                "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+            },
+        };
+    }
+    if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
+        !("statusCode" in internalEvent)) {
+        debug("Cache interception enabled");
+        internalEvent = await cacheInterceptor(internalEvent);
+        if ("statusCode" in internalEvent) {
+            applyMiddlewareHeaders(internalEvent.headers, {
+                ...middlewareResponseHeaders,
+                ...nextHeaders,
+            }, false);
+            return internalEvent;
+        }
+    }
+    // We apply the headers from the middleware response last
+    applyMiddlewareHeaders(internalEvent.headers, {
+        ...middlewareResponseHeaders,
+        ...nextHeaders,
+    });
+    return {
+        internalEvent,
+        isExternalRewrite,
+        origin: false,
+        isISR,
+    };
+}

package/dist/core/util.d.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareManifest } from "../types/next-types.js";
+export declare const requestHandler: any;
+export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifest): RegExp[];
+export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;
+export declare function setNextjsPrebundledReact(rawPath: string): void;

package/dist/core/util.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppPathsManifestKeys, NextConfig, RoutesManifest, } from "../adapters/config/index.js";
+// @ts-ignore
+import NextServer from "next/dist/server/next-server.js";
+import { debug } from "../adapters/logger.js";
+import { applyOverride as applyNextjsRequireHooksOverride, overrideHooks as overrideNextjsRequireHooks, } from "./require-hooks.js";
+// WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React — https://github.com/serverless-stack/open-next#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
+// Step 1: Need to override the require hooks for React before Next.js server
+//         overrides them with prebundled ones in the case of app dir
+// Step 2: Import Next.js server
+// Step 3: Apply the override after Next.js server is imported since the
+//         override that Next.js does is done at import time
+//#override requireHooks
+overrideNextjsRequireHooks(NextConfig);
+applyNextjsRequireHooksOverride();
+//#endOverride
+const cacheHandlerPath = require.resolve("./cache.cjs");
+// @ts-ignore
+export const requestHandler = new NextServer.default({
+    //#override requestHandlerHost
+    hostname: "localhost",
+    port: 3000,
+    //#endOverride
+    conf: {
+        ...NextConfig,
+        // Next.js compression should be disabled because of a bug in the bundled
+        // `compression` package — https://github.com/vercel/next.js/issues/11669
+        compress: false,
+        // By default, Next.js uses local disk to store ISR cache. We will use
+        // our own cache handler to store the cache on S3.
+        //#override stableIncrementalCache
+        cacheHandler: cacheHandlerPath,
+        cacheMaxMemorySize: 0,
+        //#endOverride
+        experimental: {
+            ...NextConfig.experimental,
+            // This uses the request.headers.host as the URL
+            // https://github.com/vercel/next.js/blob/canary/packages/next/src/server/next-server.ts#L1749-L1754
+            //#override trustHostHeader
+            trustHostHeader: true,
+            //#endOverride
+            //#override experimentalIncrementalCacheHandler
+            incrementalCacheHandlerPath: cacheHandlerPath,
+            //#endOverride
+        },
+    },
+    customServer: false,
+    dev: false,
+    dir: __dirname,
+}).getRequestHandler();
+export function getMiddlewareMatch(middlewareManifest) {
+    const rootMiddleware = middlewareManifest.middleware["/"];
+    if (!rootMiddleware?.matchers)
+        return [];
+    return rootMiddleware.matchers.map(({ regexp }) => new RegExp(regexp));
+}
+export function loadMiddlewareManifest(nextDir) {
+    const filePath = path.join(nextDir, "server", "middleware-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json);
+}
+//#override setNextjsPrebundledReact
+export function setNextjsPrebundledReact(rawPath) {
+    // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled React — https://github.com/serverless-stack/open-next#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
+    const routes = [
+        ...RoutesManifest.routes.static,
+        ...RoutesManifest.routes.dynamic,
+    ];
+    const route = routes.find((route) => new RegExp(route.regex).test(rawPath ?? ""));
+    const isApp = AppPathsManifestKeys.includes(route?.page ?? "");
+    debug("setNextjsPrebundledReact", { url: rawPath, isApp, route });
+    // app routes => use prebundled React
+    if (isApp) {
+        process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = NextConfig.experimental
+            .serverActions
+            ? "experimental"
+            : "next";
+        return;
+    }
+    // page routes => use node_modules React
+    process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = undefined;
+}
+//#endOverride