@opennextjs/aws 3.2.1 → 3.3.0

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
@@ -59,13 +57,11 @@ 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) => {
@@ -83,7 +79,7 @@ File ${fullFilePath} does not exist
         }
         catch (e) {
             if (alternativePath) {
-                computeCopyFilesForPage(alternativePath);
+                safeComputeCopyFilesForPage(alternativePath);
             }
         }
     };
@@ -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

@@ -1,20 +1,25 @@
 import fs from "node:fs";
 import path from "node:path";
-import { isBinaryContentType } from "../adapters/binary.js";
 import logger from "../logger.js";
+import { isBinaryContentType } from "../utils/binary.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");

package/dist/build/createMiddleware.js

@@ -11,7 +11,7 @@ import { installDependencies } from "./installDeps.js";
  * @param forceOnlyBuildOnce force to build only once.
  */
 export async function createMiddleware(options, { forceOnlyBuildOnce = false } = {}) {
-    logger.info(`Bundling middleware function...`);
+    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"));
@@ -20,18 +20,22 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
         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");
+        buildHelper.copyOpenNextConfig(options.buildDir, outputPath, await buildHelper.isEdgeRuntime(config.middleware.override));
         // Bundle middleware
         await buildEdgeBundle({
             entrypoint: path.join(options.openNextDistDir, "adapters", "middleware.js"),
             outfile: path.join(outputPath, "handler.mjs"),
             middlewareInfo,
             options,
-            overrides: config.middleware?.override,
+            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);
     }
@@ -42,6 +46,7 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
             middlewareInfo,
             options,
             onlyBuildOnce: true,
+            name: "middleware",
         });
     }
 }

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

@@ -42,28 +42,22 @@ export async function createServerBundle(options) {
     // 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", options, {
@@ -83,7 +77,6 @@ async function generateBundle(name, options, fnOptions) {
     //       `node_modules` inside `.next/standalone`, and others inside
     //       `.next/standalone/package/path` (ie. `.next`, `server.js`).
     //       We need to output the handler file inside the package path.
-    const isMonorepo = monorepoRoot !== appPath;
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
@@ -94,7 +87,9 @@ async function generateBundle(name, 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, {
+            minify: options.minify,
+        });
     }
     // Copy middleware
     if (!config.middleware?.external) {
@@ -132,20 +127,16 @@ async function generateBundle(name, 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: [
@@ -167,11 +158,14 @@ async function generateBundle(name, 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);
+    const isMonorepo = monorepoRoot !== appPath;
     if (isMonorepo) {
         addMonorepoEntrypoint(outputPath, packagePath);
     }
@@ -214,10 +208,10 @@ function addMonorepoEntrypoint(outputPath, packagePath) {
     //       that re-exports the real handler.
     // Always use posix path for import path
     const packagePosixPath = packagePath.split(path.sep).join(path.posix.sep);
-    fs.writeFileSync(path.join(outputPath, "index.mjs"), [`export * from "./${packagePosixPath}/index.mjs";`].join(""));
+    fs.writeFileSync(path.join(outputPath, "index.mjs"), `export * from "./${packagePosixPath}/index.mjs";`);
 }
 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,18 +1,22 @@
 import type { MiddlewareInfo } from "../../types/next-types";
-import type { IncludedConverter, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
-import type { BuildOptions } from "../helper.js";
+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 {
     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({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): 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,17 @@
 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 { isEdgeRuntime } from "../helper.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
-    const isInCloudfare = typeof overrides?.wrapper === "string"
-        ? overrides.wrapper === "cloudflare"
-        : (await overrides?.wrapper?.())?.edgeRuntime;
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
+    const isInCloudfare = await isEdgeRuntime(overrides);
     await esbuildAsync({
         entryPoints: [entrypoint],
-        // inject: ,
         bundle: true,
         outfile,
         external: ["node:*", "next", "@aws-sdk/*"],
@@ -41,7 +39,14 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
                                 : "sqs-lite",
                         }
                         : {}),
+                    originResolver: typeof overrides?.originResolver === "string"
+                        ? overrides.originResolver
+                        : "pattern-env",
+                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
+                        ? overrides.proxyExternalRequest
+                        : "node",
                 },
+                fnName: name,
             }),
             openNextReplacementPlugin({
                 name: "externalMiddlewareOverrides",
@@ -70,20 +75,32 @@ globalThis.Buffer = Buffer;
 
 import {AsyncLocalStorage} from "node:async_hooks";
 globalThis.AsyncLocalStorage = AsyncLocalStorage;
+
+${""
+            /**
+             * Next.js sets this `__import_unsupported` on `globalThis` (with `configurable: false`):
+             *  https://github.com/vercel/next.js/blob/5b7833e3/packages/next/src/server/web/globals.ts#L94-L98
+             *
+             * It does so in both the middleware and the main server, so if the middleware runs in the same place
+             * as the main handler this code gets run twice triggering a runtime error.
+             *
+             * For this reason we need to patch `Object.defineProperty` to avoid this issue.
+             */
+            }
+const defaultDefineProperty = Object.defineProperty;
+Object.defineProperty = function(o, p, a) {
+  if(p=== '__import_unsupported' && Boolean(globalThis.__import_unsupported)) {
+    return;
+  }
+  return defaultDefineProperty(o, p, a);
+};
+
   ${isInCloudfare
                 ? ""
                 : `
   const require = (await import("node:module")).createRequire(import.meta.url);
   const __filename = (await import("node:url")).fileURLToPath(import.meta.url);
   const __dirname = (await import("node:path")).dirname(__filename);
-
-  const defaultDefineProperty = Object.defineProperty;
-  Object.defineProperty = function(o, p, a) {
-    if(p=== '__import_unsupported' && Boolean(globalThis.__import_unsupported)) {
-      return;
-    }
-    return defaultDefineProperty(o, p, a);
-  };
   `}
   ${additionalInject ?? ""}
   `,
@@ -95,7 +112,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
             outfile,
             allowOverwrite: true,
             bundle: true,
-            minify: true,
+            minify: options.minify,
             platform: "node",
             format: "esm",
             conditions: ["workerd", "worker", "browser"],
@@ -141,5 +158,6 @@ export async function generateEdgeBundle(name, options, fnOptions) {
         options,
         overrides: fnOptions.override,
         additionalExternals: options.config.edgeExternals,
+        name,
     });
 }

package/dist/build/generateOutput.js

@@ -6,15 +6,11 @@ async function canStream(opts) {
     if (!opts.override?.wrapper) {
         return false;
     }
-    else {
-        if (typeof opts.override.wrapper === "string") {
-            return opts.override.wrapper === "aws-lambda-streaming";
-        }
-        else {
-            const wrapper = await opts.override.wrapper();
-            return wrapper.supportStreaming;
-        }
+    if (typeof opts.override.wrapper === "string") {
+        return opts.override.wrapper === "aws-lambda-streaming";
     }
+    const wrapper = await opts.override.wrapper();
+    return wrapper.supportStreaming;
 }
 async function extractOverrideName(defaultName, override) {
     if (!override) {
@@ -23,10 +19,8 @@ async function extractOverrideName(defaultName, override) {
     if (typeof override === "string") {
         return override;
     }
-    else {
-        const overrideModule = await override();
-        return overrideModule.name;
-    }
+    const overrideModule = await override();
+    return overrideModule.name;
 }
 async function extractOverrideFn(override) {
     if (!override) {
@@ -190,7 +184,7 @@ export async function generateOutput(options) {
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });
     behaviors.push({
-        pattern: "*",
+        pattern: "*", // This is the default behavior
         origin: "default",
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });

package/dist/build/helper.d.ts

@@ -1,5 +1,5 @@
 import type { BuildOptions as ESBuildOptions } from "esbuild";
-import type { OpenNextConfig } from "../types/open-next.js";
+import type { DefaultOverrideOptions, OpenNextConfig } from "../types/open-next.js";
 export type BuildOptions = ReturnType<typeof normalizeOptions>;
 export declare function normalizeOptions(config: OpenNextConfig, distDir: string, tempBuildDir: string): {
     appBuildOutputPath: string;
@@ -9,6 +9,7 @@ export declare function normalizeOptions(config: OpenNextConfig, distDir: string
     buildDir: string;
     config: OpenNextConfig;
     debug: boolean;
+    minify: boolean;
     monorepoRoot: string;
     nextVersion: string;
     openNextVersion: string;
@@ -19,15 +20,33 @@ export declare function normalizeOptions(config: OpenNextConfig, distDir: string
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
-export declare function removeFiles(root: string, conditionFn: (file: string) => boolean, searchingDir?: string): void;
+/**
+ *  Type of the parameter of `traverseFiles` callbacks
+ */
+export type TraversePath = {
+    absolutePath: string;
+    relativePath: string;
+};
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
-export declare function traverseFiles(root: string, conditionFn: (file: string) => boolean, callbackFn: (filePath: string) => void, searchingDir?: string): void;
+export declare function traverseFiles(root: string, conditionFn: (paths: TraversePath) => boolean, callbackFn: (paths: TraversePath) => void, searchingDir?: string): void;
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export declare function removeFiles(root: string, conditionFn: (paths: TraversePath) => boolean): void;
 export declare function getHtmlPages(dotNextPath: string): Set<string>;
 export declare function getBuildId(dotNextPath: string): string;
 export declare function getOpenNextVersion(): string;
@@ -50,3 +69,7 @@ export declare function printOpenNextVersion(options: BuildOptions): void;
  * the app directory, but the compiled config is in the root of the monorepo.
  */
 export declare function initOutputDir(options: BuildOptions): void;
+/**
+ * @returns Whether the edge runtime is used
+ */
+export declare function isEdgeRuntime(overrides: DefaultOverrideOptions | undefined): Promise<boolean | undefined>;