@opennextjs/aws 3.2.0 → 3.2.2

package/dist/build/copyTracedFiles.js

@@ -1,6 +1,6 @@
 import url from "node:url";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "fs";
-import path from "path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import path from "node:path";
 import logger from "../logger.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 function copyPatchFile(outputDir) {
@@ -15,9 +15,7 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
     const standaloneDir = path.join(dotNextDir, "standalone");
     const standaloneNextDir = path.join(standaloneDir, packagePath, ".next");
     const outputNextDir = path.join(outputDir, packagePath, ".next");
-    const extractFiles = (files, from = standaloneNextDir) => {
-        return files.map((f) => path.resolve(from, f));
-    };
+    const extractFiles = (files, from = standaloneNextDir) => files.map((f) => path.resolve(from, f));
     // On next 14+, we might not have to include those files
     // For next 13, we need to include them otherwise we get runtime error
     const requiredServerFiles = JSON.parse(readFileSync(path.join(dotNextDir, bundledNextServer
@@ -54,24 +52,22 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
                 throw new Error(`
 --------------------------------------------------------------------------------
 ${pagePath} cannot use the edge runtime.
-OpenNext requires edge runtime function to be defined in a separate function. 
+OpenNext requires edge runtime function to be defined in a separate function.
 See the docs for more information on how to bundle edge runtime functions.
 --------------------------------------------------------------------------------
         `);
             }
-            else {
-                throw new Error(`
+            throw new Error(`
 --------------------------------------------------------------------------------
 We cannot find the route for ${pagePath}.
 File ${fullFilePath} does not exist
 --------------------------------------------------------------------------------`);
-            }
         }
         const dir = path.dirname(fullFilePath);
         extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
             filesToCopy.set(f, f.replace(standaloneDir, outputDir));
         });
-        if (!existsSync(path.join(standaloneNextDir, `${fullFilePath}`))) {
+        if (!existsSync(path.join(standaloneNextDir, fullFilePath))) {
             throw new Error(`This error should only happen for static 404 and 500 page from page router. Report this if that's not the case.,
         File ${fullFilePath} does not exist`);
         }
@@ -144,20 +140,15 @@ File ${fullFilePath} does not exist
             copyFileSync(from, to);
         }
     });
-    readdirSync(standaloneNextDir).forEach((f) => {
-        if (statSync(path.join(standaloneNextDir, f)).isDirectory())
-            return;
-        copyFileSync(path.join(standaloneNextDir, f), path.join(outputNextDir, f));
-    });
+    readdirSync(standaloneNextDir)
+        .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, fileOrDir)).isDirectory())
+        .forEach((file) => copyFileSync(path.join(standaloneNextDir, file), path.join(outputNextDir, file)));
     // We then need to copy all the files at the root of server
     mkdirSync(path.join(outputNextDir, "server"), { recursive: true });
-    readdirSync(path.join(standaloneNextDir, "server")).forEach((f) => {
-        if (statSync(path.join(standaloneNextDir, "server", f)).isDirectory())
-            return;
-        if (f !== "server.js") {
-            copyFileSync(path.join(standaloneNextDir, "server", f), path.join(path.join(outputNextDir, "server"), f));
-        }
-    });
+    readdirSync(path.join(standaloneNextDir, "server"))
+        .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, "server", fileOrDir)).isDirectory())
+        .filter((file) => file !== "server.js")
+        .forEach((file) => copyFileSync(path.join(standaloneNextDir, "server", file), path.join(path.join(outputNextDir, "server"), file)));
     // Copy patch file
     copyPatchFile(path.join(outputDir, packagePath));
     // TODO: Recompute all the files.
@@ -198,11 +189,9 @@ File ${fullFilePath} does not exist
                 }
             }
         });
-        staticFiles.forEach((f) => {
-            if (f.endsWith(".html")) {
-                copyStaticFile(`server/${f}`);
-            }
-        });
+        staticFiles
+            .filter((file) => file.endsWith(".html"))
+            .forEach((file) => copyStaticFile(`server/${file}`));
     }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
 }

package/dist/build/createAssets.js

@@ -4,17 +4,22 @@ import { isBinaryContentType } from "../adapters/binary.js";
 import logger from "../logger.js";
 import * as buildHelper from "./helper.js";
 export function createStaticAssets(options) {
-    logger.info(`Bundling static assets...`);
+    logger.info("Bundling static assets...");
     const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "assets");
     fs.mkdirSync(outputPath, { recursive: true });
-    // Next.js outputs assets into multiple files. Copy into the same directory.
-    // Copy over:
-    // - .next/BUILD_ID => _next/BUILD_ID
-    // - .next/static   => _next/static
-    // - public/*       => *
-    // - app/favicon.ico or src/app/favicon.ico  => favicon.ico
+    /**
+     * Next.js outputs assets into multiple files. Copy into the same directory.
+     *
+     * Copy over:
+     * - .next/BUILD_ID => BUILD_ID
+     * - .next/static   => _next/static
+     * - public/*       => *
+     * - app/favicon.ico or src/app/favicon.ico  => favicon.ico
+     *
+     * Note: BUILD_ID is used by the SST infra.
+     */
     fs.copyFileSync(path.join(appBuildOutputPath, ".next/BUILD_ID"), path.join(outputPath, "BUILD_ID"));
     fs.cpSync(path.join(appBuildOutputPath, ".next/static"), path.join(outputPath, "_next", "static"), { recursive: true });
     if (fs.existsSync(appPublicPath)) {
@@ -24,7 +29,9 @@ export function createStaticAssets(options) {
         ? "src/app"
         : "app";
     const faviconPath = path.join(appPath, appSrcPath, "favicon.ico");
-    if (fs.existsSync(faviconPath)) {
+    // We need to check if the favicon is either a file or directory.
+    // If it's a directory, we assume it's a route handler and ignore it.
+    if (fs.existsSync(faviconPath) && fs.lstatSync(faviconPath).isFile()) {
         fs.copyFileSync(faviconPath, path.join(outputPath, "favicon.ico"));
     }
 }
@@ -35,7 +42,7 @@ export function createStaticAssets(options) {
  * @returns Whether tag cache is used.
  */
 export function createCacheAssets(options) {
-    logger.info(`Bundling cache assets...`);
+    logger.info("Bundling cache assets...");
     const { appBuildOutputPath, outputDir } = options;
     const packagePath = path.relative(options.monorepoRoot, appBuildOutputPath);
     const buildId = buildHelper.getBuildId(appBuildOutputPath);
@@ -49,27 +56,29 @@ export function createCacheAssets(options) {
         .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
     // Remove non-cache files
     const htmlPages = buildHelper.getHtmlPages(dotNextPath);
-    buildHelper.removeFiles(outputPath, (file) => file.endsWith(".js") ||
-        file.endsWith(".js.nft.json") ||
-        (file.endsWith(".html") && htmlPages.has(file)));
+    buildHelper.removeFiles(outputPath, ({ relativePath }) => relativePath.endsWith(".js") ||
+        relativePath.endsWith(".js.nft.json") ||
+        (relativePath.endsWith(".html") && htmlPages.has(relativePath)));
     // Merge cache files into a single file
     const cacheFilesPath = {};
-    buildHelper.traverseFiles(outputPath, () => true, (filepath) => {
-        const ext = path.extname(filepath);
+    buildHelper.traverseFiles(outputPath, () => true, ({ absolutePath }) => {
+        const ext = path.extname(absolutePath);
         switch (ext) {
             case ".meta":
             case ".html":
             case ".json":
             case ".body":
-            case ".rsc":
-                const newFilePath = filepath
-                    .substring(0, filepath.length - ext.length)
-                    .replace(/\.prefetch$/, "") + ".cache";
+            case ".rsc": {
+                const newFilePath = absolutePath
+                    .substring(0, absolutePath.length - ext.length)
+                    .replace(/\.prefetch$/, "")
+                    .concat(".cache");
                 cacheFilesPath[newFilePath] = {
-                    [ext.slice(1)]: filepath,
+                    [ext.slice(1)]: absolutePath,
                     ...cacheFilesPath[newFilePath],
                 };
                 break;
+            }
             case ".map":
                 break;
             default:
@@ -106,8 +115,8 @@ export function createCacheAssets(options) {
         const metaFiles = [];
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
-        buildHelper.traverseFiles(outputPath, (file) => file.endsWith(".meta"), (filePath) => {
-            const fileContent = fs.readFileSync(filePath, "utf8");
+        buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
+            const fileContent = fs.readFileSync(absolutePath, "utf8");
             const fileData = JSON.parse(fileContent);
             if (fileData.headers?.["x-next-cache-tags"]) {
                 fileData.headers["x-next-cache-tags"]
@@ -117,7 +126,7 @@ export function createCacheAssets(options) {
                     metaFiles.push({
                         tag: { S: path.posix.join(buildId, tag.trim()) },
                         path: {
-                            S: path.posix.join(buildId, path.relative(outputPath, filePath).replace(".meta", "")),
+                            S: path.posix.join(buildId, relativePath.replace(".meta", "")),
                         },
                         // We don't care about the revalidation time here, we just need to make sure it's there
                         revalidatedAt: { N: "1" },
@@ -131,14 +140,14 @@ export function createCacheAssets(options) {
             const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
             fs.mkdirSync(fetchOutputPath, { recursive: true });
             fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
-            buildHelper.traverseFiles(fetchCachePath, () => true, (filepath) => {
-                const fileContent = fs.readFileSync(filepath, "utf8");
+            buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
+                const fileContent = fs.readFileSync(absolutePath, "utf8");
                 const fileData = JSON.parse(fileContent);
                 fileData?.tags?.forEach((tag) => {
                     metaFiles.push({
                         tag: { S: path.posix.join(buildId, tag) },
                         path: {
-                            S: path.posix.join(buildId, path.relative(fetchCachePath, filepath)),
+                            S: path.posix.join(buildId, relativePath),
                         },
                         revalidatedAt: { N: "1" },
                     });
@@ -156,6 +165,6 @@ export function createCacheAssets(options) {
         }
     }
     // We need to remove files later because we need the metafiles for dynamodb tags cache
-    buildHelper.removeFiles(outputPath, (file) => !file.endsWith(".cache"));
+    buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
     return { useTagCache };
 }

package/dist/build/createImageOptimizationBundle.js

@@ -8,7 +8,7 @@ import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 const require = createRequire(import.meta.url);
 export async function createImageOptimizationBundle(options) {
-    logger.info(`Bundling image optimization function...`);
+    logger.info("Bundling image optimization function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "image-optimization-function");
@@ -75,5 +75,8 @@ export async function createImageOptimizationBundle(options) {
     const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
     installDependencies(outputPath, config.imageOptimization?.install ?? {
         packages: [`sharp@${sharpVersion}`],
+        arch: "arm64",
+        nodeVersion: "18",
+        libc: "glibc",
     });
 }

package/dist/build/createMiddleware.d.ts

@@ -3,8 +3,8 @@ import * as buildHelper from "./helper.js";
  * Compiles the middleware bundle.
  *
  * @param options Build Options.
- * @returns Whether the app uses a Middleware.
+ * @param forceOnlyBuildOnce force to build only once.
  */
-export declare function createMiddleware(options: buildHelper.BuildOptions): Promise<{
-    useMiddleware: boolean;
-}>;
+export declare function createMiddleware(options: buildHelper.BuildOptions, { forceOnlyBuildOnce }?: {
+    forceOnlyBuildOnce?: boolean | undefined;
+}): Promise<void>;

package/dist/build/createMiddleware.js

@@ -8,26 +8,16 @@ import { installDependencies } from "./installDeps.js";
  * Compiles the middleware bundle.
  *
  * @param options Build Options.
- * @returns Whether the app uses a Middleware.
+ * @param forceOnlyBuildOnce force to build only once.
  */
-export async function createMiddleware(options) {
-    logger.info(`Bundling middleware function...`);
+export async function createMiddleware(options, { forceOnlyBuildOnce = false } = {}) {
+    logger.info("Bundling middleware function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Get middleware manifest
     const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
-    const entry = middlewareManifest.middleware["/"];
-    if (!entry) {
-        return { useMiddleware: false };
-    }
-    // Create output folder
-    let outputPath = path.join(outputDir, "server-function");
-    const commonMiddlewareOptions = {
-        middlewareInfo: entry,
-        options,
-        appBuildOutputPath,
-    };
+    const middlewareInfo = middlewareManifest.middleware["/"];
     if (config.middleware?.external) {
-        outputPath = path.join(outputDir, "middleware");
+        const outputPath = path.join(outputDir, "middleware");
         fs.mkdirSync(outputPath, { recursive: true });
         // Copy open-next.config.mjs
         buildHelper.copyOpenNextConfig(options.buildDir, outputPath, config.middleware.override?.wrapper === "cloudflare");
@@ -35,11 +25,17 @@ export async function createMiddleware(options) {
         await buildEdgeBundle({
             entrypoint: path.join(options.openNextDistDir, "adapters", "middleware.js"),
             outfile: path.join(outputPath, "handler.mjs"),
-            ...commonMiddlewareOptions,
-            overrides: config.middleware?.override,
+            middlewareInfo,
+            options,
+            overrides: {
+                ...config.middleware.override,
+                originResolver: config.middleware.originResolver,
+            },
             defaultConverter: "aws-cloudfront",
             includeCache: config.dangerous?.enableCacheInterception,
             additionalExternals: config.edgeExternals,
+            onlyBuildOnce: forceOnlyBuildOnce === true,
+            name: "middleware",
         });
         installDependencies(outputPath, config.middleware?.install);
     }
@@ -47,9 +43,10 @@ export async function createMiddleware(options) {
         await buildEdgeBundle({
             entrypoint: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
             outfile: path.join(options.buildDir, "middleware.mjs"),
-            ...commonMiddlewareOptions,
+            middlewareInfo,
+            options,
             onlyBuildOnce: true,
+            name: "middleware",
         });
     }
-    return { useMiddleware: true };
 }

package/dist/build/createRevalidationBundle.js

@@ -5,7 +5,7 @@ import { openNextResolvePlugin } from "../plugins/resolve.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 export async function createRevalidationBundle(options) {
-    logger.info(`Bundling revalidation function...`);
+    logger.info("Bundling revalidation function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "revalidation-function");

package/dist/build/createServerBundle.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
@@ -11,7 +10,6 @@ import { copyTracedFiles } from "./copyTracedFiles.js";
 import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
-const require = createRequire(import.meta.url);
 export async function createServerBundle(options) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -27,56 +25,50 @@ export async function createServerBundle(options) {
         const routes = fnOptions.routes;
         routes.forEach((route) => foundRoutes.add(route));
         if (fnOptions.runtime === "edge") {
-            await generateEdgeBundle(name, config, options, fnOptions);
+            await generateEdgeBundle(name, options, fnOptions);
         }
         else {
-            await generateBundle(name, config, options, fnOptions);
+            await generateBundle(name, options, fnOptions);
         }
     });
     //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
     // We build every other function than default before so we know which route there is left
     await Promise.all(promises);
     const remainingRoutes = new Set();
-    const { monorepoRoot, appBuildOutputPath } = options;
+    const { appBuildOutputPath, monorepoRoot } = options;
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     // Find remaining routes
     const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
     // Find app dir routes
     if (fs.existsSync(path.join(serverPath, "app"))) {
         const appPath = path.join(serverPath, "app");
-        buildHelper.traverseFiles(appPath, (file) => {
-            if (file.endsWith("page.js") || file.endsWith("route.js")) {
-                const route = `app/${file.replace(/\.js$/, "")}`;
-                if (!foundRoutes.has(route)) {
-                    remainingRoutes.add(route);
-                }
+        buildHelper.traverseFiles(appPath, ({ relativePath }) => relativePath.endsWith("page.js") || relativePath.endsWith("route.js"), ({ relativePath }) => {
+            const route = `app/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
             }
-            return false;
-        }, () => { });
+        });
     }
     // Find pages dir routes
     if (fs.existsSync(path.join(serverPath, "pages"))) {
         const pagePath = path.join(serverPath, "pages");
-        buildHelper.traverseFiles(pagePath, (file) => {
-            if (file.endsWith(".js")) {
-                const route = `pages/${file.replace(/\.js$/, "")}`;
-                if (!foundRoutes.has(route)) {
-                    remainingRoutes.add(route);
-                }
+        buildHelper.traverseFiles(pagePath, ({ relativePath }) => relativePath.endsWith(".js"), ({ relativePath }) => {
+            const route = `pages/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
             }
-            return false;
-        }, () => { });
+        });
     }
     // Generate default function
-    await generateBundle("default", config, options, {
+    await generateBundle("default", options, {
         ...defaultFn,
         // @ts-expect-error - Those string are RouteTemplate
         routes: Array.from(remainingRoutes),
         patterns: ["*"],
     });
 }
-async function generateBundle(name, config, options, fnOptions) {
-    const { appPath, appBuildOutputPath, outputDir, monorepoRoot } = options;
+async function generateBundle(name, options, fnOptions) {
+    const { appPath, appBuildOutputPath, config, outputDir, monorepoRoot } = options;
     logger.info(`Building server function: ${name}...`);
     // Create output folder
     const outputPath = path.join(outputDir, "server-functions", name);
@@ -96,11 +88,12 @@ async function generateBundle(name, config, options, fnOptions) {
     // Bundle next server if necessary
     const isBundled = fnOptions.experimentalBundledNextServer ?? false;
     if (isBundled) {
-        await bundleNextServer(path.join(outputPath, packagePath), appPath);
+        await bundleNextServer(path.join(outputPath, packagePath), appPath, {
+            debug: options.debug,
+        });
     }
     // Copy middleware
-    if (!config.middleware?.external &&
-        fs.existsSync(path.join(options.buildDir, "middleware.mjs"))) {
+    if (!config.middleware?.external) {
         fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
     }
     // Copy open-next.config.mjs
@@ -123,12 +116,10 @@ async function generateBundle(name, config, options, fnOptions) {
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
             target: /core(\/|\\)requestHandler\.js/g,
-            deletes: disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : [],
-            replacements: disableRouting
-                ? [
-                    require.resolve("../adapters/plugins/without-routing/requestHandler.js"),
-                ]
-                : [],
+            deletes: [
+                ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
+                ...(disableRouting ? ["withRouting"] : []),
+            ],
         }),
         openNextReplacementPlugin({
             name: `utilOverride ${name}`,
@@ -137,20 +128,16 @@ async function generateBundle(name, config, options, fnOptions) {
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
                 ...(disableRouting ? ["trustHostHeader"] : []),
                 ...(!isBefore13413 ? ["requestHandlerHost"] : []),
-                ...(!isAfter141 ? ["stableIncrementalCache"] : []),
-                ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : []),
+                ...(isAfter141
+                    ? ["experimentalIncrementalCacheHandler"]
+                    : ["stableIncrementalCache"]),
             ],
         }),
         openNextResolvePlugin({
             fnName: name,
-            overrides: overrides,
+            overrides,
         }),
     ];
-    if (plugins && plugins.length > 0) {
-        logger.debug(`Applying plugins:: [${plugins
-            .map(({ name }) => name)
-            .join(",")}] for Next version: ${options.nextVersion}`);
-    }
     const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
     await buildHelper.esbuildAsync({
         entryPoints: [
@@ -172,9 +159,11 @@ async function generateBundle(name, config, options, fnOptions) {
         },
         plugins,
         alias: {
-            "next/dist/server/next-server.js": isBundled
-                ? "./next-server.runtime.prod.js"
-                : "next/dist/server/next-server.js",
+            ...(isBundled
+                ? {
+                    "next/dist/server/next-server.js": "./next-server.runtime.prod.js",
+                }
+                : {}),
         },
     }, options);
     if (isMonorepo) {
@@ -222,7 +211,7 @@ function addMonorepoEntrypoint(outputPath, packagePath) {
     fs.writeFileSync(path.join(outputPath, "index.mjs"), [`export * from "./${packagePosixPath}/index.mjs";`].join(""));
 }
 async function minifyServerBundle(outputDir) {
-    logger.info(`Minimizing server function...`);
+    logger.info("Minimizing server function...");
     await minifyAll(outputDir, {
         compress_json: true,
         mangle: true,

package/dist/build/createWarmerBundle.js

@@ -5,7 +5,7 @@ import { openNextResolvePlugin } from "../plugins/resolve.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 export async function createWarmerBundle(options) {
-    logger.info(`Bundling warmer function...`);
+    logger.info("Bundling warmer function...");
     const { config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "warmer-function");

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,20 +1,22 @@
 import type { MiddlewareInfo } from "../../types/next-types";
-import type { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { OriginResolver } from "../../types/overrides.js";
 import type { BuildOptions } from "../helper.js";
 interface BuildEdgeBundleOptions {
-    appBuildOutputPath: string;
-    middlewareInfo: MiddlewareInfo;
+    middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
-    overrides?: OverrideOptions;
+    overrides?: OverrideOptions & {
+        originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
+    };
     defaultConverter?: IncludedConverter;
     additionalInject?: string;
     includeCache?: boolean;
     additionalExternals?: string[];
     onlyBuildOnce?: boolean;
+    name: string;
 }
-export declare function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
-export declare function copyMiddlewareAssetsAndWasm({}: {}): void;
-export declare function generateEdgeBundle(name: string, config: OpenNextConfig, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
+export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }: BuildEdgeBundleOptions): Promise<void>;
+export declare function generateEdgeBundle(name: string, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
 export {};

package/dist/build/edge/createEdgeBundle.js

@@ -1,19 +1,18 @@
 import { mkdirSync } from "node:fs";
+import fs from "node:fs";
+import path from "node:path";
 import { build } from "esbuild";
-import fs from "fs";
-import path from "path";
 import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
     const isInCloudfare = typeof overrides?.wrapper === "string"
         ? overrides.wrapper === "cloudflare"
         : (await overrides?.wrapper?.())?.edgeRuntime;
     await esbuildAsync({
         entryPoints: [entrypoint],
-        // inject: ,
         bundle: true,
         outfile,
         external: ["node:*", "next", "@aws-sdk/*"],
@@ -41,7 +40,14 @@ export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entr
                                 : "sqs-lite",
                         }
                         : {}),
+                    originResolver: typeof overrides?.originResolver === "string"
+                        ? overrides.originResolver
+                        : "pattern-env",
+                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
+                        ? overrides.proxyExternalRequest
+                        : "node",
                 },
+                fnName: name,
             }),
             openNextReplacementPlugin({
                 name: "externalMiddlewareOverrides",
@@ -50,7 +56,7 @@ export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entr
             }),
             openNextEdgePlugins({
                 middlewareInfo,
-                nextDir: path.join(appBuildOutputPath, ".next"),
+                nextDir: path.join(options.appBuildOutputPath, ".next"),
                 edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
                 isInCloudfare,
             }),
@@ -95,7 +101,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
             outfile,
             allowOverwrite: true,
             bundle: true,
-            minify: true,
+            minify: !options.debug,
             platform: "node",
             format: "esm",
             conditions: ["workerd", "worker", "browser"],
@@ -106,8 +112,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
         });
     }
 }
-export function copyMiddlewareAssetsAndWasm({}) { }
-export async function generateEdgeBundle(name, config, options, fnOptions) {
+export async function generateEdgeBundle(name, options, fnOptions) {
     const { appBuildOutputPath, outputDir } = options;
     logger.info(`Generating edge bundle for: ${name}`);
     // Create output folder
@@ -122,26 +127,26 @@ export async function generateEdgeBundle(name, config, options, fnOptions) {
     if (functions.length > 1) {
         throw new Error("Only one function is supported for now");
     }
-    const fn = functions[0];
+    const middlewareInfo = functions[0];
     //Copy wasm files
-    const wasmFiles = fn.wasm;
+    const wasmFiles = middlewareInfo.wasm;
     mkdirSync(path.join(outputPath, "wasm"), { recursive: true });
     for (const wasmFile of wasmFiles) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", wasmFile.filePath), path.join(outputPath, `wasm/${wasmFile.name}.wasm`));
     }
     // Copy assets
-    const assets = fn.assets;
+    const assets = middlewareInfo.assets;
     mkdirSync(path.join(outputPath, "assets"), { recursive: true });
     for (const asset of assets) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", asset.filePath), path.join(outputPath, `assets/${asset.name}`));
     }
     await buildEdgeBundle({
-        appBuildOutputPath,
-        middlewareInfo: fn,
+        middlewareInfo,
         entrypoint: path.join(options.openNextDistDir, "adapters", "edge-adapter.js"),
         outfile: path.join(outputPath, "index.mjs"),
         options,
         overrides: fnOptions.override,
-        additionalExternals: config.edgeExternals,
+        additionalExternals: options.config.edgeExternals,
+        name,
     });
 }