@opennextjs/aws 3.4.2 → 3.5.1

package/dist/overrides/converters/aws-apigw-v2.js

@@ -2,7 +2,7 @@ import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery } from "../../core/routing/util";
-import { removeUndefinedFromQuery } from "./utils";
+import { extractHostFromHeaders, removeUndefinedFromQuery } from "./utils";
 // Not sure which one is really needed as this is not documented anywhere but server actions redirect are not working without this,
 // it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
 const CloudFrontBlacklistedHeaders = [
@@ -54,13 +54,14 @@ function normalizeAPIGatewayProxyEventV2Headers(event) {
 }
 async function convertFromAPIGatewayProxyEventV2(event) {
     const { rawPath, rawQueryString, requestContext } = event;
+    const headers = normalizeAPIGatewayProxyEventV2Headers(event);
     return {
         type: "core",
         method: requestContext.http.method,
         rawPath,
-        url: rawPath + (rawQueryString ? `?${rawQueryString}` : ""),
+        url: `https://${extractHostFromHeaders(headers)}${rawPath}${rawQueryString ? `?${rawQueryString}` : ""}`,
         body: normalizeAPIGatewayProxyEventV2Body(event),
-        headers: normalizeAPIGatewayProxyEventV2Headers(event),
+        headers,
         remoteAddress: requestContext.http.sourceIp,
         query: removeUndefinedFromQuery(convertToQuery(rawQueryString)),
         cookies: event.cookies?.reduce((acc, cur) => {

package/dist/overrides/converters/aws-cloudfront.js

@@ -2,6 +2,7 @@ import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery, convertToQueryString } from "../../core/routing/util";
+import { extractHostFromHeaders } from "./utils";
 const cloudfrontBlacklistedHeaders = [
     // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
     "connection",
@@ -56,17 +57,18 @@ function normalizeCloudFrontRequestEventHeaders(rawHeaders) {
     return headers;
 }
 async function convertFromCloudFrontRequestEvent(event) {
-    const { method, uri, querystring, body, headers, clientIp } = event.Records[0].cf.request;
+    const { method, uri, querystring, body, headers: cfHeaders, clientIp, } = event.Records[0].cf.request;
+    const headers = normalizeCloudFrontRequestEventHeaders(cfHeaders);
     return {
         type: "core",
         method,
         rawPath: uri,
-        url: uri + (querystring ? `?${querystring}` : ""),
+        url: `https://${extractHostFromHeaders(headers)}${uri}${querystring ? `?${querystring}` : ""}`,
         body: Buffer.from(body?.data ?? "", body?.encoding === "base64" ? "base64" : "utf8"),
-        headers: normalizeCloudFrontRequestEventHeaders(headers),
+        headers,
         remoteAddress: clientIp,
         query: convertToQuery(querystring),
-        cookies: headers.cookie?.reduce((acc, cur) => {
+        cookies: cfHeaders.cookie?.reduce((acc, cur) => {
             const { key = "", value } = cur;
             acc[key] = value;
             return acc;

package/dist/overrides/converters/edge.js

@@ -42,16 +42,7 @@ const converter = {
     },
     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 request = new Request(url, {
+            const request = new Request(result.internalEvent.url, {
                 body: result.internalEvent.body,
                 method: result.internalEvent.method,
                 headers: {

package/dist/overrides/converters/node.js

@@ -1,4 +1,5 @@
 import { parseCookies } from "../../http/util";
+import { extractHostFromHeaders } from "./utils";
 const converter = {
     convertFrom: async (req) => {
         const body = await new Promise((resolve) => {
@@ -10,20 +11,21 @@ const converter = {
                 resolve(Buffer.concat(chunks));
             });
         });
-        const url = new URL(req.url, `http://${req.headers.host}`);
+        const headers = Object.fromEntries(Object.entries(req.headers ?? {})
+            .map(([key, value]) => [
+            key.toLowerCase(),
+            Array.isArray(value) ? value.join(",") : value,
+        ])
+            .filter(([key]) => key));
+        const url = new URL(req.url, `http://${extractHostFromHeaders(headers)}`);
         const query = Object.fromEntries(url.searchParams.entries());
         return {
             type: "core",
             method: req.method ?? "GET",
             rawPath: url.pathname,
-            url: url.pathname + url.search,
+            url: url.href,
             body,
-            headers: Object.fromEntries(Object.entries(req.headers ?? {})
-                .map(([key, value]) => [
-                key.toLowerCase(),
-                Array.isArray(value) ? value.join(",") : value,
-            ])
-                .filter(([key]) => key)),
+            headers,
             remoteAddress: req.headers["x-forwarded-for"] ??
                 req.socket.remoteAddress ??
                 "::1",

package/dist/overrides/converters/utils.d.ts

@@ -1 +1,8 @@
 export declare function removeUndefinedFromQuery(query: Record<string, string | string[] | undefined>): Record<string, string | string[]>;
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export declare function extractHostFromHeaders(headers: Record<string, string>): string;

package/dist/overrides/converters/utils.js

@@ -7,3 +7,12 @@ export function removeUndefinedFromQuery(query) {
     }
     return newQuery;
 }
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export function extractHostFromHeaders(headers) {
+    return headers["x-forwarded-host"] ?? headers.host ?? "on";
+}

package/dist/overrides/imageLoader/s3-lite.d.ts

@@ -0,0 +1,3 @@
+import type { ImageLoader } from "../../types/overrides";
+declare const s3Loader: ImageLoader;
+export default s3Loader;

package/dist/overrides/imageLoader/s3-lite.js

@@ -0,0 +1,61 @@
+import { Readable } from "node:stream";
+import { AwsClient } from "aws4fetch";
+import { FatalError } from "../../utils/error";
+let awsClient = null;
+const { BUCKET_NAME, BUCKET_KEY_PREFIX } = process.env;
+// https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+// If AWS_REGION is defined it will override AWS_DEFAULT_REGION
+const BUCKET_REGION = process.env.BUCKET_REGION ??
+    process.env.AWS_REGION ??
+    process.env.AWS_DEFAULT_REGION;
+const getAwsClient = () => {
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: BUCKET_REGION,
+    });
+    return awsClient;
+};
+function ensureEnvExists() {
+    if (!(BUCKET_NAME || BUCKET_KEY_PREFIX || BUCKET_REGION)) {
+        throw new FatalError("Bucket name, region and key prefix must be defined!");
+    }
+}
+const awsFetch = async (key, options) => {
+    const client = getAwsClient();
+    const url = `https://${BUCKET_NAME}.s3.${BUCKET_REGION}.amazonaws.com/${key}`;
+    return client.fetch(url, options);
+};
+const s3Loader = {
+    name: "s3-lite",
+    load: async (key) => {
+        ensureEnvExists();
+        const keyPrefix = BUCKET_KEY_PREFIX?.replace(/^\/|\/$/g, "");
+        const response = await awsFetch(keyPrefix
+            ? `${keyPrefix}/${key.replace(/^\//, "")}`
+            : key.replace(/^\//, ""), {
+            method: "GET",
+        });
+        if (response.status === 404) {
+            throw new FatalError("The specified key does not exist.");
+        }
+        if (response.status !== 200) {
+            throw new FatalError(`Failed to get image. Status code: ${response.status}`);
+        }
+        if (!response.body) {
+            throw new FatalError("No body in aws4fetch s3 response");
+        }
+        // We need to cast it else there will be a TypeError: o.pipe is not a function
+        const body = Readable.fromWeb(response.body);
+        return {
+            body: body,
+            contentType: response.headers.get("content-type") ?? undefined,
+            cacheControl: response.headers.get("cache-control") ?? undefined,
+        };
+    },
+};
+export default s3Loader;

package/dist/overrides/tagCache/dummy.js

@@ -1,6 +1,7 @@
 // We don't want to throw error on this one because we might use it when we don't need tag cache
 const dummyTagCache = {
     name: "dummy",
+    mode: "original",
     getByPath: async () => {
         return [];
     },

package/dist/overrides/tagCache/dynamodb-lite.js

@@ -47,6 +47,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {

package/dist/overrides/tagCache/dynamodb-nextMode.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    mode: "nextMode";
+    hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
+    writeTags: (tags: string[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/tagCache/dynamodb-nextMode.js

@@ -0,0 +1,119 @@
+import { AwsClient } from "aws4fetch";
+import { RecoverableError } from "../../utils/error";
+import { customFetchClient } from "../../utils/fetch";
+import path from "node:path";
+import { debug, error } from "../../adapters/logger";
+import { chunk, parseNumberFromEnv } from "../../adapters/util";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
+let awsClient = null;
+const getAwsClient = () => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: CACHE_BUCKET_REGION,
+        retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+    });
+    return awsClient;
+};
+const awsFetch = (body, type = "query") => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://dynamodb.${CACHE_BUCKET_REGION}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": `DynamoDB_20120810.${type === "query" ? "BatchGetItem" : "BatchWriteItem"}`,
+        },
+        body,
+    });
+};
+function buildDynamoKey(key) {
+    const { NEXT_BUILD_ID } = process.env;
+    // FIXME: We should probably use something else than path.join here
+    // this could transform some fetch cache key into a valid path
+    return path.posix.join(NEXT_BUILD_ID ?? "", "_tag", key);
+}
+// We use the same key for both path and tag
+// That's mostly for compatibility reason so that it's easier to use this with existing infra
+// FIXME: Allow a simpler object without an unnecessary path key
+function buildDynamoObject(tag, revalidatedAt) {
+    return {
+        path: { S: buildDynamoKey(tag) },
+        tag: { S: buildDynamoKey(tag) },
+        revalidatedAt: { N: `${revalidatedAt ?? Date.now()}` },
+    };
+}
+// This implementation does not support automatic invalidation of paths by the cdn
+export default {
+    name: "ddb-nextMode",
+    mode: "nextMode",
+    hasBeenRevalidated: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        if (tags.length > 100) {
+            throw new RecoverableError("Cannot query more than 100 tags at once. You should not be using this tagCache implementation for this amount of tags");
+        }
+        const { CACHE_DYNAMO_TABLE } = process.env;
+        // It's unlikely that we will have more than 100 items to query
+        // If that's the case, you should not use this tagCache implementation
+        const response = await awsFetch(JSON.stringify({
+            RequestItems: {
+                [CACHE_DYNAMO_TABLE ?? ""]: {
+                    Keys: tags.map((tag) => ({
+                        path: { S: buildDynamoKey(tag) },
+                        tag: { S: buildDynamoKey(tag) },
+                    })),
+                },
+            },
+        }), "query");
+        if (response.status !== 200) {
+            throw new RecoverableError(`Failed to query dynamo item: ${response.status}`);
+        }
+        // Now we need to check for every item if lastModified is greater than the revalidatedAt
+        const { Responses } = await response.json();
+        if (!Responses) {
+            return false;
+        }
+        const revalidatedTags = Responses[CACHE_DYNAMO_TABLE ?? ""].filter((item) => Number.parseInt(item.revalidatedAt.N) > (lastModified ?? 0));
+        debug("retrieved tags", revalidatedTags);
+        return revalidatedTags.length > 0;
+    },
+    writeTags: async (tags) => {
+        try {
+            const { CACHE_DYNAMO_TABLE } = process.env;
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+                return;
+            }
+            const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
+                RequestItems: {
+                    [CACHE_DYNAMO_TABLE ?? ""]: Items.map((tag) => ({
+                        PutRequest: {
+                            Item: {
+                                ...buildDynamoObject(tag),
+                            },
+                        },
+                    })),
+                },
+            }));
+            const toInsert = chunk(dataChunks, getDynamoBatchWriteCommandConcurrency());
+            for (const paramsChunk of toInsert) {
+                await Promise.all(paramsChunk.map(async (params) => {
+                    const response = await awsFetch(JSON.stringify(params), "batchWrite");
+                    if (response.status !== 200) {
+                        throw new RecoverableError(`Failed to batch write dynamo item: ${response.status}`);
+                    }
+                    return response;
+                }));
+            }
+        }
+        catch (e) {
+            error("Failed to batch write dynamo item", e);
+        }
+    },
+};

package/dist/overrides/tagCache/dynamodb.js

@@ -25,6 +25,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {

package/dist/overrides/tagCache/fs-dev.js

@@ -4,6 +4,7 @@ const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
 const tagCache = {
     name: "fs-dev",
+    mode: "original",
     getByPath: async (path) => {
         return tags
             .filter((tagPathMapping) => tagPathMapping.path.S === path)

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

@@ -63,7 +63,7 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return compressedStream ?? responseStream;
         },
     };
-    const response = await handler(internalEvent, streamCreator);
+    const response = await handler(internalEvent, { streamCreator });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");

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

@@ -26,7 +26,9 @@ const handler = async (handler, converter) => async (event) => {
             });
         },
     };
-    const response = await handler(internalEvent, fakeStream);
+    const response = await handler(internalEvent, {
+        streamCreator: fakeStream,
+    });
     return converter.convertTo(response, event);
 };
 export default {

package/dist/overrides/wrappers/cloudflare-edge.js

@@ -9,7 +9,6 @@ const cfPropNameMapping = {
 };
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
-    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -33,7 +32,9 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
                 : propValue;
         }
     }
-    const response = await handler(internalEvent);
+    const response = await handler(internalEvent, {
+        waitUntil: ctx.waitUntil.bind(ctx),
+    });
     const result = await converter.convertTo(response);
     return result;
 };

package/dist/overrides/wrappers/cloudflare-node.js

@@ -3,7 +3,6 @@ import { Writable } from "node:stream";
 const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
-    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -12,12 +11,7 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
         }
     }
     const internalEvent = await converter.convertFrom(request);
-    // TODO:
-    // The edge converter populate event.url with the url including the origin.
-    // This is required for middleware to keep track of the protocol (i.e. http with wrangler dev).
-    // However the server expects that the origin is not included.
-    const url = new URL(internalEvent.url);
-    internalEvent.url = url.href.slice(url.origin.length);
+    const url = new URL(request.url);
     const { promise: promiseResponse, resolve: resolveResponse } = Promise.withResolvers();
     const streamCreator = {
         writeHeaders(prelude) {
@@ -45,7 +39,10 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
             return Writable.fromWeb(writable);
         },
     };
-    ctx.waitUntil(handler(internalEvent, streamCreator));
+    ctx.waitUntil(handler(internalEvent, {
+        streamCreator,
+        waitUntil: ctx.waitUntil.bind(ctx),
+    }));
     return promiseResponse;
 };
 export default {

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,6 @@
 const dummyWrapper = async (handler, converter) => {
-    return async (event, responseStream) => {
-        return await handler(event, responseStream);
+    return async (event, options) => {
+        return await handler(event, options);
     };
 };
 export default {

package/dist/overrides/wrappers/express-dev.js

@@ -7,24 +7,24 @@ const wrapper = async (handler, converter) => {
     const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
     app.all("/_next/image", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
         };
-        await imageHandler(internalEvent, _res);
+        await imageHandler(internalEvent, { streamCreator });
     });
     app.all("*paths", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
             onFinish: () => { },
         };
-        await handler(internalEvent, _res);
+        await handler(internalEvent, { streamCreator });
     });
     const server = app.listen(Number.parseInt(process.env.PORT ?? "3000", 10), () => {
         console.log(`Server running on port ${process.env.PORT ?? 3000}`);

package/dist/overrides/wrappers/node.js

@@ -3,7 +3,7 @@ import { debug, error } from "../../adapters/logger";
 const wrapper = async (handler, converter) => {
     const server = createServer(async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
@@ -19,7 +19,7 @@ const wrapper = async (handler, converter) => {
             res.end("OK");
         }
         else {
-            await handler(internalEvent, _res);
+            await handler(internalEvent, { streamCreator });
         }
     });
     await new Promise((resolve) => {

package/dist/plugins/edge.d.ts

@@ -2,15 +2,13 @@ import type { Plugin } from "esbuild";
 import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
-    edgeFunctionHandlerPath?: string;
     middlewareInfo?: MiddlewareInfo;
     isInCloudfare?: boolean;
 }
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;
+export declare function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -1,17 +1,16 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
+export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }) {
     const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
     const routes = middlewareInfo
         ? [
@@ -27,14 +26,6 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
         name: "opennext-edge",
         setup(build) {
             logger.debug(chalk.blue("OpenNext Edge plugin"));
-            if (edgeFunctionHandlerPath) {
-                // If we bundle the routing, we need to resolve the middleware
-                build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => {
-                    return {
-                        path: edgeFunctionHandlerPath,
-                    };
-                });
-            }
             build.onResolve({ filter: /\.(mjs|wasm)$/g }, () => {
                 return {
                     external: true,
@@ -129,6 +120,7 @@ ${contents}
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const AppPathsManifest = loadAppPathsManifest(nextDir);
                 const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
+                const FunctionsConfigManifest = loadFunctionsConfigManifest(nextDir);
                 const contents = `
   import path from "node:path";
 
@@ -151,6 +143,7 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
   export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
   export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+  export const FunctionsConfigManifest = ${JSON.stringify(FunctionsConfigManifest)};
 
 
   process.env.NEXT_BUILD_ID = BuildId;

package/dist/plugins/externalMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare function openNextExternalMiddlewarePlugin(functionPath: string): Plugin;

package/dist/plugins/externalMiddleware.js

@@ -0,0 +1,10 @@
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
+export function openNextExternalMiddlewarePlugin(functionPath) {
+    return {
+        name: "open-next-external-node-middleware",
+        setup(build) {
+            // If we bundle the routing, we need to resolve the middleware
+            build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => ({ path: functionPath }));
+        },
+    };
+}

package/dist/plugins/resolve.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import chalk from "chalk";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -44,7 +44,7 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
         setup(build) {
             logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${fnName}` : "");
             build.onLoad({ filter: getCrossPlatformPathRegex("core/resolve.js") }, async (args) => {
-                let contents = readFileSync(args.path, "utf-8");
+                let contents = await readFile(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});
                 for (let [overrideName, overrideValue] of overridesEntries) {
                     if (!overrideValue) {