@opennextjs/aws 3.2.2 → 3.3.1

package/README.md

@@ -77,18 +77,23 @@ To run `OpenNext` locally:
 
 1. Clone this repository.
 1. Build `open-next`:
+
    ```bash
    cd packages/open-next
    pnpm build
    ```
+
 1. Run `open-next` in watch mode:
+
    ```bash
    pnpm dev
    ```
+
 1. Now, you can make changes in `open-next` and build your Next.js app to test the changes.
+
    ```bash
    cd path/to/my/nextjs/app
-   path/to/open-next/packages/open-next/dist/index.js build
+   path/to/opennextjs-aws/packages/open-next/dist/index.js build
    ```
 
 ### Coldstart

package/dist/adapters/cache.d.ts

@@ -58,8 +58,7 @@ interface CacheHandlerValue {
     cacheState?: string;
     value: IncrementalCacheValue | null;
 }
-export declare function hasCacheExtension(key: string): boolean;
-export default class S3Cache {
+export default class Cache {
     get(key: string, options?: boolean | {
         fetchCache?: boolean;
         kindHint?: "app" | "pages" | "fetch";

package/dist/adapters/cache.js

@@ -1,10 +1,5 @@
-import { isBinaryContentType } from "./binary";
+import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
-/** Beginning single backslash is intentional, to look for the dot + the extension. Do not escape it again. */
-const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
-export function hasCacheExtension(key) {
-    return CACHE_EXTENSION_REGEX.test(key);
-}
 function isFetchCache(options) {
     if (typeof options === "boolean") {
         return options;
@@ -17,7 +12,7 @@ function isFetchCache(options) {
     return false;
 }
 // We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
-export default class S3Cache {
+export default class Cache {
     async get(key, 
     // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
     options) {
@@ -34,7 +29,6 @@ export default class S3Cache {
         debug("get fetch cache", { key, softTags, tags });
         try {
             const { value, lastModified } = await globalThis.incrementalCache.get(key, true);
-            // const { Body, LastModified } = await this.getS3Object(key, "fetch");
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {
                 // If some tags are stale we need to force revalidation
@@ -71,10 +65,6 @@ export default class S3Cache {
     async getIncrementalCache(key) {
         try {
             const { value: cacheData, lastModified } = await globalThis.incrementalCache.get(key, false);
-            // const { Body, LastModified } = await this.getS3Object(key, "cache");
-            // const cacheData = JSON.parse(
-            //   (await Body?.transformToString()) ?? "{}",
-            // ) as S3CachedFile;
             const meta = cacheData?.meta;
             const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
             if (_lastModified === -1) {

package/dist/adapters/config/index.d.ts

@@ -25,3 +25,5 @@ export declare const ConfigHeaders: import("../../types/next-types").Header[] |
 export declare const PrerenderManifest: import("../../types/next-types").PrerenderManifest;
 export declare const AppPathsManifestKeys: string[];
 export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;
+export declare const AppPathsManifest: Record<string, string>;
+export declare const AppPathRoutesManifest: Record<string, string>;

package/dist/adapters/config/index.js

@@ -1,8 +1,6 @@
 import path from "node:path";
 import { debug } from "../logger";
-import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, 
-// loadPublicAssets,
-loadRoutesManifest, } from "./util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
 export const NEXT_DIR = path.join(__dirname, ".next");
 export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
 debug({ NEXT_DIR, OPEN_NEXT_DIR });
@@ -19,3 +17,6 @@ export const AppPathsManifestKeys =
 /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest = 
 /* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);
+export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
+export const AppPathRoutesManifest = 
+/* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);

package/dist/adapters/config/util.d.ts

@@ -24,5 +24,7 @@ export declare function loadRoutesManifest(nextDir: string): {
 };
 export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types").Header[] | undefined;
 export declare function loadPrerenderManifest(nextDir: string): PrerenderManifest;
+export declare function loadAppPathsManifest(nextDir: string): Record<string, string>;
+export declare function loadAppPathRoutesManifest(nextDir: string): Record<string, string>;
 export declare function loadAppPathsManifestKeys(nextDir: string): string[];
 export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;

package/dist/adapters/config/util.js

@@ -60,12 +60,22 @@ export function loadPrerenderManifest(nextDir) {
     const json = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(json);
 }
-export function loadAppPathsManifestKeys(nextDir) {
+export function loadAppPathsManifest(nextDir) {
     const appPathsManifestPath = path.join(nextDir, "server", "app-paths-manifest.json");
     const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
         ? fs.readFileSync(appPathsManifestPath, "utf-8")
         : "{}";
-    const appPathsManifest = JSON.parse(appPathsManifestJson);
+    return JSON.parse(appPathsManifestJson);
+}
+export function loadAppPathRoutesManifest(nextDir) {
+    const appPathRoutesManifestPath = path.join(nextDir, "app-path-routes-manifest.json");
+    if (fs.existsSync(appPathRoutesManifestPath)) {
+        return JSON.parse(fs.readFileSync(appPathRoutesManifestPath, "utf-8"));
+    }
+    return {};
+}
+export function loadAppPathsManifestKeys(nextDir) {
+    const appPathsManifest = loadAppPathsManifest(nextDir);
     return Object.keys(appPathsManifest).map((key) => {
         // Remove parallel route
         let cleanedKey = key.replace(/\/@[^\/]+/g, "");

package/dist/adapters/image-optimization-adapter.d.ts

@@ -1,4 +1,3 @@
-import type { StreamCreator } from "../http/openNextResponse.js";
-import type { InternalEvent, InternalResult } from "../types/open-next.js";
+import type { InternalEvent, InternalResult, StreamCreator } from "../types/open-next.js";
 export declare const handler: (...args: any[]) => any;
 export declare function defaultHandler(event: InternalEvent, streamCreator?: StreamCreator): Promise<InternalResult>;

package/dist/adapters/logger.js

@@ -1,3 +1,4 @@
+import { isOpenNextError } from "../utils/error";
 export function debug(...args) {
     if (globalThis.openNextDebug) {
         console.log(...args);
@@ -22,23 +23,24 @@ export function error(...args) {
     if (args.some((arg) => isDownplayedErrorLog(arg))) {
         debug(...args);
     }
-    else if (args.some((arg) => arg.__openNextInternal)) {
+    else if (args.some((arg) => isOpenNextError(arg))) {
         // In case of an internal error, we log it with the appropriate log level
-        const error = args.find((arg) => arg.__openNextInternal);
-        if (error.logLevel === 0) {
-            debug(...args);
+        const error = args.find((arg) => isOpenNextError(arg));
+        if (error.logLevel < getOpenNextErrorLogLevel()) {
             return;
         }
+        if (error.logLevel === 0) {
+            // Display the name and the message instead of full Open Next errors.
+            // console.log is used so that logging does not depend on openNextDebug.
+            return console.log(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
+        }
         if (error.logLevel === 1) {
-            warn(...args);
-            return;
+            // Display the name and the message instead of full Open Next errors.
+            return warn(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
         }
-        console.error(...args);
-        return;
-    }
-    else {
-        console.error(...args);
+        return console.error(...args);
     }
+    console.error(...args);
 }
 export const awsLogger = {
     trace: () => { },
@@ -47,3 +49,22 @@ export const awsLogger = {
     warn,
     error,
 };
+/**
+ * Retrieves the log level for internal errors from the
+ * OPEN_NEXT_ERROR_LOG_LEVEL environment variable.
+ *
+ * @returns The numerical log level 0 (debug), 1 (warn), or 2 (error)
+ */
+function getOpenNextErrorLogLevel() {
+    const strLevel = process.env.OPEN_NEXT_ERROR_LOG_LEVEL ?? "1";
+    switch (strLevel.toLowerCase()) {
+        case "debug":
+        case "0":
+            return 0;
+        case "error":
+        case "2":
+            return 2;
+        default:
+            return 1;
+    }
+}

package/dist/adapters/middleware.js

@@ -2,7 +2,7 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
-import routingHandler from "../core/routingHandler";
+import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent) => {
@@ -22,10 +22,19 @@ const defaultHandler = async (internalEvent) => {
                 const origin = await originResolver.resolve(result.internalEvent.rawPath);
                 return {
                     type: "middleware",
-                    internalEvent: result.internalEvent,
+                    internalEvent: {
+                        ...result.internalEvent,
+                        headers: {
+                            ...result.internalEvent.headers,
+                            [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
+                            [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes) ?? "[]",
+                        },
+                    },
                     isExternalRewrite: result.isExternalRewrite,
                     origin,
                     isISR: result.isISR,
+                    initialPath: result.initialPath,
+                    resolvedRoutes: result.resolvedRoutes,
                 };
             }
             try {
@@ -45,6 +54,8 @@ const defaultHandler = async (internalEvent) => {
                     isExternalRewrite: false,
                     origin: false,
                     isISR: result.isISR,
+                    initialPath: result.internalEvent.rawPath,
+                    resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }
         }

package/dist/adapters/plugins/image-optimization/image-optimization.d.ts

@@ -8,4 +8,5 @@ export declare function optimizeImage(headers: APIGatewayProxyEventHeaders, imag
     maxAge: number;
     etag: string;
     upstreamEtag: string;
+    error?: unknown;
 }>;

package/dist/adapters/plugins/image-optimization/image-optimization.js

@@ -5,7 +5,6 @@ import { debug } from "../../logger.js";
 export async function optimizeImage(headers, imageParams, nextConfig, handleRequest) {
     const result = await imageOptimizer({ headers }, {}, // res object is not necessary as it's not actually used.
     imageParams, nextConfig, false, // not in dev mode
-    // @ts-expect-error - This file is used only for Next 14.1 and below. Typing is correct for these versions.
     handleRequest);
     debug("optimized result", result);
     return result;

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.d.ts

@@ -8,4 +8,5 @@ export declare function optimizeImage(headers: APIGatewayProxyEventHeaders, imag
     maxAge: number;
     etag: string;
     upstreamEtag: string;
+    error?: unknown;
 }>;

package/dist/adapters/util.js

@@ -1,6 +1,10 @@
 //TODO: We should probably move all the utils to a separate location
 export function setNodeEnv() {
-    process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
+    // Note: we create a `processEnv` variable instead of just using `process.env` directly
+    //       because build tools can substitute `process.env.NODE_ENV` on build making
+    //       assignments such as `process.env.NODE_ENV = ...` problematic
+    const processEnv = process.env;
+    processEnv.NODE_ENV = process.env.NODE_ENV ?? "production";
 }
 export function generateUniqueId() {
     return Math.random().toString(36).slice(2, 8);

package/dist/build/bundleNextServer.d.ts

@@ -1,3 +1,3 @@
-export declare function bundleNextServer(outputDir: string, appPath: string, { debug }: {
-    debug?: boolean | undefined;
+export declare function bundleNextServer(outputDir: string, appPath: string, { minify }: {
+    minify?: boolean | undefined;
 }): Promise<void>;

package/dist/build/bundleNextServer.js

@@ -35,7 +35,7 @@ const externals = [
     // Adding it cause to add a lot of unnecessary deps
     "next/dist/compiled/next-server",
 ];
-export async function bundleNextServer(outputDir, appPath, { debug = false }) {
+export async function bundleNextServer(outputDir, appPath, { minify = true }) {
     const require = createRequire(`${appPath}/package.json`);
     const entrypoint = require.resolve("next/dist/esm/server/next-server.js");
     await build({
@@ -46,7 +46,7 @@ export async function bundleNextServer(outputDir, appPath, { debug = false }) {
         // packages: "external",
         format: "cjs",
         external: externals,
-        minify: !debug,
+        minify,
         outfile: path.join(outputDir, "next-server.runtime.prod.js"),
         sourcemap: false,
         plugins: [

package/dist/build/copyTracedFiles.js

@@ -79,7 +79,7 @@ File ${fullFilePath} does not exist
         }
         catch (e) {
             if (alternativePath) {
-                computeCopyFilesForPage(alternativePath);
+                safeComputeCopyFilesForPage(alternativePath);
             }
         }
     };

package/dist/build/createAssets.js

@@ -1,7 +1,7 @@
 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...");
@@ -109,10 +109,29 @@ export function createCacheAssets(options) {
         };
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
+    // We need to traverse the cache to find every .meta file
+    const metaFiles = [];
+    // Copy fetch-cache to cache folder
+    const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
+    if (fs.existsSync(fetchCachePath)) {
+        const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
+        fs.mkdirSync(fetchOutputPath, { recursive: true });
+        fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
+        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, relativePath),
+                    },
+                    revalidatedAt: { N: "1" },
+                });
+            });
+        });
+    }
     if (!options.config.dangerous?.disableTagCache) {
-        // Generate dynamodb data
-        // We need to traverse the cache to find every .meta file
-        const metaFiles = [];
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
         buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
@@ -134,26 +153,6 @@ export function createCacheAssets(options) {
                 });
             }
         });
-        // Copy fetch-cache to cache folder
-        const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
-        if (fs.existsSync(fetchCachePath)) {
-            const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
-            fs.mkdirSync(fetchOutputPath, { recursive: true });
-            fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
-            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, relativePath),
-                        },
-                        revalidatedAt: { N: "1" },
-                    });
-                });
-            });
-        }
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");

package/dist/build/createMiddleware.js

@@ -20,7 +20,7 @@ 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"),

package/dist/build/createServerBundle.js

@@ -77,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";
@@ -89,7 +88,7 @@ async function generateBundle(name, options, fnOptions) {
     const isBundled = fnOptions.experimentalBundledNextServer ?? false;
     if (isBundled) {
         await bundleNextServer(path.join(outputPath, packagePath), appPath, {
-            debug: options.debug,
+            minify: options.minify,
         });
     }
     // Copy middleware
@@ -166,6 +165,7 @@ async function generateBundle(name, options, fnOptions) {
                 : {}),
         },
     }, options);
+    const isMonorepo = monorepoRoot !== appPath;
     if (isMonorepo) {
         addMonorepoEntrypoint(outputPath, packagePath);
     }
@@ -208,7 +208,7 @@ 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...");

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

@@ -1,15 +1,16 @@
 import type { MiddlewareInfo } from "../../types/next-types";
 import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
 import type { OriginResolver } from "../../types/overrides.js";
-import type { BuildOptions } from "../helper.js";
+import { type BuildOptions } from "../helper.js";
+type Override = OverrideOptions & {
+    originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
+};
 interface BuildEdgeBundleOptions {
     middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
-    overrides?: OverrideOptions & {
-        originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
-    };
+    overrides?: Override;
     defaultConverter?: IncludedConverter;
     additionalInject?: string;
     includeCache?: boolean;

package/dist/build/edge/createEdgeBundle.js

@@ -6,11 +6,15 @@ 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, name, }) {
-    const isInCloudfare = typeof overrides?.wrapper === "string"
-        ? overrides.wrapper === "cloudflare"
-        : (await overrides?.wrapper?.())?.edgeRuntime;
+    const isInCloudfare = await isEdgeRuntime(overrides);
+    function override(target) {
+        return typeof overrides?.[target] === "string"
+            ? overrides[target]
+            : undefined;
+    }
     await esbuildAsync({
         entryPoints: [entrypoint],
         bundle: true,
@@ -21,31 +25,17 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
         plugins: [
             openNextResolvePlugin({
                 overrides: {
-                    wrapper: typeof overrides?.wrapper === "string"
-                        ? overrides.wrapper
-                        : "aws-lambda",
-                    converter: typeof overrides?.converter === "string"
-                        ? overrides.converter
-                        : defaultConverter,
+                    wrapper: override("wrapper") ?? "aws-lambda",
+                    converter: override("converter") ?? defaultConverter,
                     ...(includeCache
                         ? {
-                            tagCache: typeof overrides?.tagCache === "string"
-                                ? overrides.tagCache
-                                : "dynamodb-lite",
-                            incrementalCache: typeof overrides?.incrementalCache === "string"
-                                ? overrides.incrementalCache
-                                : "s3-lite",
-                            queue: typeof overrides?.queue === "string"
-                                ? overrides.queue
-                                : "sqs-lite",
+                            tagCache: override("tagCache") ?? "dynamodb-lite",
+                            incrementalCache: override("incrementalCache") ?? "s3-lite",
+                            queue: override("queue") ?? "sqs-lite",
                         }
                         : {}),
-                    originResolver: typeof overrides?.originResolver === "string"
-                        ? overrides.originResolver
-                        : "pattern-env",
-                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
-                        ? overrides.proxyExternalRequest
-                        : "node",
+                    originResolver: override("originResolver") ?? "pattern-env",
+                    proxyExternalRequest: override("proxyExternalRequest") ?? "node",
                 },
                 fnName: name,
             }),
@@ -76,20 +66,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 ?? ""}
   `,
@@ -101,7 +103,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
             outfile,
             allowOverwrite: true,
             bundle: true,
-            minify: !options.debug,
+            minify: options.minify,
             platform: "node",
             format: "esm",
             conditions: ["workerd", "worker", "browser"],

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;
@@ -68,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>;

package/dist/build/helper.js

@@ -21,6 +21,7 @@ export function normalizeOptions(config, distDir, tempBuildDir) {
     else {
         appPackageJsonPath = findNextPackageJsonPath(appPath, monorepoRoot);
     }
+    const debug = Boolean(process.env.OPEN_NEXT_DEBUG) ?? false;
     return {
         appBuildOutputPath: buildOutputPath,
         appPackageJsonPath,
@@ -28,7 +29,9 @@ export function normalizeOptions(config, distDir, tempBuildDir) {
         appPublicPath: path.join(appPath, "public"),
         buildDir: path.join(outputDir, ".build"),
         config,
-        debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
+        debug,
+        // Whether ESBuild should minify the code
+        minify: !debug,
         monorepoRoot,
         nextVersion: getNextVersion(appPath),
         openNextVersion: getOpenNextVersion(),
@@ -68,13 +71,13 @@ function findNextPackageJsonPath(appPath, root) {
         : path.join(root, "./package.json");
 }
 export function esbuildSync(esbuildOptions, options) {
-    const { openNextVersion, debug } = options;
+    const { openNextVersion, debug, minify } = options;
     const result = buildSync({
         target: "esnext",
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: !debug,
+        minify,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -95,13 +98,13 @@ export function esbuildSync(esbuildOptions, options) {
     }
 }
 export async function esbuildAsync(esbuildOptions, options) {
-    const { openNextVersion, debug } = options;
+    const { openNextVersion, debug, minify } = options;
     const result = await buildAsync({
         target: "esnext",
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: !debug,
+        minify,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -261,3 +264,15 @@ export function initOutputDir(options) {
     fs.mkdirSync(buildDir, { recursive: true });
     fs.cpSync(options.tempBuildDir, buildDir, { recursive: true });
 }
+/**
+ * @returns Whether the edge runtime is used
+ */
+export async function isEdgeRuntime(overrides) {
+    if (!overrides?.wrapper) {
+        return false;
+    }
+    if (typeof overrides.wrapper === "string") {
+        return ["cloudflare-edge", "cloudflare"].includes(overrides.wrapper);
+    }
+    return (await overrides?.wrapper?.())?.edgeRuntime;
+}