@opennextjs/aws 3.6.5 → 3.7.0

package/README.md

@@ -23,7 +23,7 @@ OpenNext takes the Next.js build output and converts it into packages that can b
 
 ## Features
 
-OpenNext aims to support all Next.js 14 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
+OpenNext aims to support all Next.js 15 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
 
 - [x] App & Pages Router
 - [x] API routes

package/dist/adapters/cache.js

@@ -1,4 +1,4 @@
-import { getTagsFromValue, hasBeenRevalidated } from "../utils/cache";
+import { getTagsFromValue, hasBeenRevalidated, writeTags } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
 function isFetchCache(options) {
@@ -246,7 +246,7 @@ export default class Cache {
         try {
             if (globalThis.tagCache.mode === "nextMode") {
                 const paths = (await globalThis.tagCache.getPathsByTags?.(_tags)) ?? [];
-                await globalThis.tagCache.writeTags(_tags);
+                await writeTags(_tags);
                 if (paths.length > 0) {
                     // TODO: we should introduce a new method in cdnInvalidationHandler to invalidate paths by tags for cdn that supports it
                     // It also means that we'll need to provide the tags used in every request to the wrapper or converter.
@@ -291,7 +291,7 @@ export default class Cache {
                     }
                 }
                 // Update all keys with the given tag with revalidatedAt set to now
-                await globalThis.tagCache.writeTags(toInsert);
+                await writeTags(toInsert);
                 // We can now invalidate all paths in the CDN
                 // This only applies to `revalidateTag`, not to `res.revalidate()`
                 const uniquePaths = Array.from(new Set(toInsert
@@ -340,7 +340,7 @@ export default class Cache {
         const storedTags = await globalThis.tagCache.getByPath(key);
         const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
         if (tagsToWrite.length > 0) {
-            await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({
+            await writeTags(tagsToWrite.map((tag) => ({
                 path: key,
                 tag: tag,
                 // In case the tags are not there we just need to create them

package/dist/adapters/composable-cache.js

@@ -1,8 +1,15 @@
+import { writeTags } from "../utils/cache";
 import { fromReadableStream, toReadableStream } from "../utils/stream";
 import { debug } from "./logger";
+const pendingWritePromiseMap = new Map();
 export default {
     async get(cacheKey) {
         try {
+            // We first check if we have a pending write for this cache key
+            // If we do, we return the pending promise instead of fetching the cache
+            if (pendingWritePromiseMap.has(cacheKey)) {
+                return pendingWritePromiseMap.get(cacheKey);
+            }
             const result = await globalThis.incrementalCache.get(cacheKey, "composable");
             if (!result?.value?.value) {
                 return undefined;
@@ -32,7 +39,10 @@ export default {
         }
     },
     async set(cacheKey, pendingEntry) {
-        const entry = await pendingEntry;
+        pendingWritePromiseMap.set(cacheKey, pendingEntry);
+        const entry = await pendingEntry.finally(() => {
+            pendingWritePromiseMap.delete(cacheKey);
+        });
         const valueToStore = await fromReadableStream(entry.value);
         await globalThis.incrementalCache.set(cacheKey, {
             ...entry,
@@ -42,7 +52,7 @@ export default {
             const storedTags = await globalThis.tagCache.getByPath(cacheKey);
             const tagsToWrite = entry.tags.filter((tag) => !storedTags.includes(tag));
             if (tagsToWrite.length > 0) {
-                await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
+                await writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
             }
         }
     },
@@ -60,7 +70,7 @@ export default {
     },
     async expireTags(...tags) {
         if (globalThis.tagCache.mode === "nextMode") {
-            return globalThis.tagCache.writeTags(tags);
+            return writeTags(tags);
         }
         const tagCache = globalThis.tagCache;
         const revalidatedAt = Date.now();
@@ -79,7 +89,7 @@ export default {
         for (const entry of pathsToUpdate.flat()) {
             setToWrite.add(entry);
         }
-        await globalThis.tagCache.writeTags(Array.from(setToWrite));
+        await writeTags(Array.from(setToWrite));
     },
     // This one is necessary for older versions of next
     async receiveExpiredTags(...tags) {

package/dist/adapters/edge-adapter.js

@@ -4,11 +4,15 @@ import { emptyReadableStream } from "../utils/stream";
 import { NextConfig } from "../adapters/config";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { convertBodyToReadableStream } from "../core/routing/util";
+import { INTERNAL_EVENT_REQUEST_ID } from "../core/routingHandler";
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
     globalThis.isEdgeRuntime = true;
+    const requestId = globalThis.openNextConfig.middleware?.external
+        ? internalEvent.headers[INTERNAL_EVENT_REQUEST_ID]
+        : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in edge runtime functions
-    return runWithOpenNextRequestContext({ isISRRevalidation: false, waitUntil: options?.waitUntil }, async () => {
+    return runWithOpenNextRequestContext({ isISRRevalidation: false, waitUntil: options?.waitUntil, requestId }, async () => {
         // @ts-expect-error - This is bundled
         const handler = await import("./middleware.mjs");
         const response = await handler.default({

package/dist/adapters/middleware.js

@@ -1,25 +1,29 @@
 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 { resolveAssetResolver, resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
 import { constructNextUrl } from "../core/routing/util";
-import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
-    const originResolver = await resolveOriginResolver(globalThis.openNextConfig.middleware?.originResolver);
-    const externalRequestProxy = await resolveProxyRequest(globalThis.openNextConfig.middleware?.override?.proxyExternalRequest);
+    const config = globalThis.openNextConfig.middleware;
+    const originResolver = await resolveOriginResolver(config?.originResolver);
+    const externalRequestProxy = await resolveProxyRequest(config?.override?.proxyExternalRequest);
+    const assetResolver = await resolveAssetResolver(config?.assetResolver);
     //#override includeCacheInMiddleware
-    globalThis.tagCache = await resolveTagCache(globalThis.openNextConfig.middleware?.override?.tagCache);
-    globalThis.queue = await resolveQueue(globalThis.openNextConfig.middleware?.override?.queue);
-    globalThis.incrementalCache = await resolveIncrementalCache(globalThis.openNextConfig.middleware?.override?.incrementalCache);
+    globalThis.tagCache = await resolveTagCache(config?.override?.tagCache);
+    globalThis.queue = await resolveQueue(config?.override?.queue);
+    globalThis.incrementalCache = await resolveIncrementalCache(config?.override?.incrementalCache);
     //#endOverride
+    const requestId = Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the external middleware
     return runWithOpenNextRequestContext({
         isISRRevalidation: internalEvent.headers["x-isr"] === "1",
         waitUntil: options?.waitUntil,
+        requestId,
     }, async () => {
-        const result = await routingHandler(internalEvent);
+        const result = await routingHandler(internalEvent, { assetResolver });
         if ("internalEvent" in result) {
             debug("Middleware intercepted event", internalEvent);
             if (!result.isExternalRewrite) {
@@ -32,6 +36,7 @@ const defaultHandler = async (internalEvent, options) => {
                             ...result.internalEvent.headers,
                             [INTERNAL_HEADER_INITIAL_URL]: internalEvent.url,
                             [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes),
+                            [INTERNAL_EVENT_REQUEST_ID]: requestId,
                         },
                     },
                     isExternalRewrite: result.isExternalRewrite,
@@ -50,6 +55,10 @@ const defaultHandler = async (internalEvent, options) => {
                     type: "middleware",
                     internalEvent: {
                         ...result.internalEvent,
+                        headers: {
+                            ...result.internalEvent.headers,
+                            [INTERNAL_EVENT_REQUEST_ID]: requestId,
+                        },
                         rawPath: "/500",
                         url: constructNextUrl(result.internalEvent.url, "/500"),
                         method: "GET",
@@ -63,6 +72,7 @@ const defaultHandler = async (internalEvent, options) => {
                 };
             }
         }
+        result.headers[INTERNAL_EVENT_REQUEST_ID] = requestId;
         debug("Middleware response", result);
         return result;
     });

package/dist/build/copyTracedFiles.js

@@ -1,5 +1,5 @@
 import url from "node:url";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { loadAppPathsManifest, loadBuildId, loadConfig, loadFunctionsConfigManifest, loadMiddlewareManifest, loadPagesManifest, loadPrerenderManifest, } from "../adapters/config/util.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -223,15 +223,15 @@ File ${serverPath} does not exist
             copyFileSync(path.join(standaloneNextDir, filePath), path.join(outputNextDir, filePath));
         }
     };
+    const manifests = getManifests(standaloneNextDir);
+    const { config, prerenderManifest, pagesManifest } = manifests;
     // Get all the static files - Should be only for pages dir
     // Ideally we would filter only those that might get accessed in this specific functions
     // Maybe even move this to s3 directly
     if (hasPageDir) {
         // First we get truly static files - i.e. pages without getStaticProps
-        const staticFiles = Object.values(loadPagesManifest(standaloneNextDir));
+        const staticFiles = Object.values(pagesManifest);
         // Then we need to get all fallback: true dynamic routes html
-        const prerenderManifest = loadPrerenderManifest(standaloneNextDir);
-        const config = loadConfig(standaloneNextDir);
         const locales = config.i18n?.locales;
         Object.values(prerenderManifest.dynamicRoutes).forEach((route) => {
             if (typeof route.fallback === "string") {
@@ -249,10 +249,15 @@ File ${serverPath} does not exist
             .filter((file) => file.endsWith(".html"))
             .forEach((file) => copyStaticFile(`server/${file}`));
     }
+    // Copy .next/static/css from standalone to output dir
+    // needed for optimizeCss feature to work
+    if (config.experimental.optimizeCss) {
+        cpSync(path.join(standaloneNextDir, "static", "css"), path.join(outputNextDir, "static", "css"), { recursive: true });
+    }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
     return {
         tracedFiles,
         nodePackages,
-        manifests: getManifests(standaloneNextDir),
+        manifests,
     };
 }

package/dist/build/createAssets.js

@@ -62,44 +62,46 @@ export function createCacheAssets(options) {
     const packagePath = buildHelper.getPackagePath(options);
     const buildId = buildHelper.getBuildId(options);
     let useTagCache = false;
-    // Copy pages to cache folder
     const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
-    const outputPath = path.join(outputDir, "cache", buildId);
-    [".next/server/pages", ".next/server/app"]
+    const outputCachePath = path.join(outputDir, "cache", buildId);
+    fs.mkdirSync(outputCachePath, { recursive: true });
+    const sourceDirs = [".next/server/pages", ".next/server/app"]
         .map((dir) => path.join(dotNextPath, dir))
-        .filter(fs.existsSync)
-        .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
-    // Remove non-cache files
+        .filter(fs.existsSync);
     const htmlPages = buildHelper.getHtmlPages(dotNextPath);
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => relativePath.endsWith(".js") ||
+    const isFileSkipped = (relativePath) => relativePath.endsWith(".js") ||
         relativePath.endsWith(".js.nft.json") ||
-        (relativePath.endsWith(".html") && htmlPages.has(relativePath)));
+        (relativePath.endsWith(".html") && htmlPages.has(relativePath));
     // Merge cache files into a single file
     const cacheFilesPath = {};
-    buildHelper.traverseFiles(outputPath, () => true, ({ absolutePath }) => {
-        const ext = path.extname(absolutePath);
-        switch (ext) {
-            case ".meta":
-            case ".html":
-            case ".json":
-            case ".body":
-            case ".rsc": {
-                const newFilePath = absolutePath
-                    .substring(0, absolutePath.length - ext.length)
-                    .replace(/\.prefetch$/, "")
-                    .concat(".cache");
-                cacheFilesPath[newFilePath] = {
-                    [ext.slice(1)]: absolutePath,
-                    ...cacheFilesPath[newFilePath],
-                };
-                break;
+    // Process each source directory
+    sourceDirs.forEach((sourceDir) => {
+        buildHelper.traverseFiles(sourceDir, ({ relativePath }) => !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
+            const ext = path.extname(absolutePath);
+            switch (ext) {
+                case ".meta":
+                case ".html":
+                case ".json":
+                case ".body":
+                case ".rsc": {
+                    const newFilePath = path
+                        .join(outputCachePath, relativePath)
+                        .substring(0, path.join(outputCachePath, relativePath).length - ext.length)
+                        .replace(/\.prefetch$/, "")
+                        .concat(".cache");
+                    cacheFilesPath[newFilePath] = {
+                        [ext.slice(1)]: absolutePath,
+                        ...cacheFilesPath[newFilePath],
+                    };
+                    break;
+                }
+                case ".map":
+                    break;
+                default:
+                    logger.warn(`Unknown file extension: ${ext}`);
+                    break;
             }
-            case ".map":
-                break;
-            default:
-                logger.warn(`Unknown file extension: ${ext}`);
-                break;
-        }
+        });
     });
     // Generate cache file
     Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
@@ -122,6 +124,8 @@ export function createCacheAssets(options) {
                     : "utf8")
                 : undefined,
         };
+        // Ensure directory exists before writing
+        fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
     // We need to traverse the cache to find every .meta file
@@ -149,36 +153,36 @@ export function createCacheAssets(options) {
     if (!options.config.dangerous?.disableTagCache) {
         // 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 }) => {
-            const fileContent = fs.readFileSync(absolutePath, "utf8");
-            const fileData = JSON.parse(fileContent);
-            if (fileData.headers?.["x-next-cache-tags"]) {
-                fileData.headers["x-next-cache-tags"]
-                    .split(",")
-                    .forEach((tag) => {
-                    // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
-                    metaFiles.push({
-                        tag: { S: path.posix.join(buildId, tag.trim()) },
-                        path: {
-                            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" },
+        sourceDirs.forEach((sourceDir) => {
+            buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ 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"]
+                        .split(",")
+                        .forEach((tag) => {
+                        // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
+                        metaFiles.push({
+                            tag: { S: path.posix.join(buildId, tag.trim()) },
+                            path: {
+                                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" },
+                        });
                     });
-                });
-            }
+                }
+            });
         });
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");
-            //Copy open-next.config.mjs into the bundle
+            // Copy open-next.config.mjs into the bundle
             fs.mkdirSync(providerPath, { recursive: true });
             buildHelper.copyOpenNextConfig(options.buildDir, providerPath);
             // TODO: check if metafiles doesn't contain duplicates
             fs.writeFileSync(path.join(providerPath, "dynamodb-cache.json"), JSON.stringify(metaFiles));
         }
     }
-    // We need to remove files later because we need the metafiles for dynamodb tags cache
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
     return { useTagCache, metaFiles };
 }

package/dist/build/createServerBundle.js

@@ -126,7 +126,6 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patches.patchEnvVars,
         patches.patchBackgroundRevalidation,
         patches.patchUseCacheForISR,
-        patches.patchDropBabel,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

package/dist/build/patch/patches/index.d.ts

@@ -3,4 +3,3 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
-export { patchDropBabel } from "./dropBabel.js";

package/dist/build/patch/patches/index.js

@@ -3,4 +3,3 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
-export { patchDropBabel } from "./dropBabel.js";

package/dist/build/patch/patches/patchNextServer.d.ts

@@ -1,5 +1,15 @@
 import type { CodePatcher } from "../codePatcher.js";
-export declare const minimalRule = "\nrule:\n  kind: member_expression\n  pattern: process.env.NEXT_MINIMAL\n  any:\n    - inside:\n        kind: parenthesized_expression\n        stopBy: end\n        inside:\n          kind: if_statement\n          any:\n            - inside:\n                kind: statement_block\n                inside:\n                  kind: method_definition\n                  any:\n                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}\n                    - has: {kind: property_identifier, field: name, regex: runMiddleware}\n                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}\n            - has:\n                kind: statement_block\n                has:\n                  kind: expression_statement\n                  pattern: res.statusCode = 400;\nfix:\n  'true'\n";
-export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any: \n      - has: \n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has: \n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
-export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: getMiddlewareManifest\nfix:\n  '{return null;}'\n";
+export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any:\n      - has:\n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has:\n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
+export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: ^getMiddlewareManifest$\nfix:\n  '{return null;}'\n";
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @returns A rule to replace the body with a `throw`
+ */
+export declare function createEmptyBodyRule(methodName: string): string;
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ */
+export declare const errorInspectRule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";
 export declare const patchNextServer: CodePatcher;

package/dist/build/patch/patches/patchNextServer.js

@@ -1,51 +1,24 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
-// This rule will replace the `NEXT_MINIMAL` env variable with true in multiple places to avoid executing unwanted path (i.e. next middleware, edge functions and image optimization)
-export const minimalRule = `
-rule:
-  kind: member_expression
-  pattern: process.env.NEXT_MINIMAL
-  any:
-    - inside:
-        kind: parenthesized_expression
-        stopBy: end
-        inside:
-          kind: if_statement
-          any:
-            - inside:
-                kind: statement_block
-                inside:
-                  kind: method_definition
-                  any:
-                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}
-                    - has: {kind: property_identifier, field: name, regex: runMiddleware}
-                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}
-            - has:
-                kind: statement_block
-                has:
-                  kind: expression_statement
-                  pattern: res.statusCode = 400;
-fix:
-  'true'
-`;
-// This rule will disable the background preloading of route done by NextServer by default during the creation of NextServer
+// Disable the background preloading of route done by NextServer by default during the creation of NextServer
 export const disablePreloadingRule = `
 rule:
   kind: statement_block
   inside:
     kind: if_statement
-    any: 
-      - has: 
+    any:
+      - has:
           kind: member_expression
           pattern: this.nextConfig.experimental.preloadEntriesOnStart
           stopBy: end
-      - has: 
+      - has:
           kind: binary_expression
           pattern: appDocumentPreloading === true
           stopBy: end
 fix:
   '{}'
 `;
-// This rule is mostly for splitted edge functions so that we don't try to match them on the other non edge functions
+// Mostly for splitted edge functions so that we don't try to match them on the other non edge functions
 export const removeMiddlewareManifestRule = `
 rule:
   kind: statement_block
@@ -53,39 +26,104 @@ rule:
     kind: method_definition
     has:
       kind: property_identifier
-      regex: getMiddlewareManifest
+      regex: ^getMiddlewareManifest$
 fix:
   '{return null;}'
 `;
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @returns A rule to replace the body with a `throw`
+ */
+export function createEmptyBodyRule(methodName) {
+    return `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { async ${methodName}($$$PARAMS) { $$$_ } }"
+fix: |-
+  async ${methodName}($$$PARAMS) {
+    throw new Error("${methodName} should not be called with OpenNext");
+  }
+`;
+}
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ */
+export const errorInspectRule = `
+rule:
+  pattern: require("./node-environment-extensions/error-inspect");
+fix: |-
+  // Removed by OpenNext
+  // require("./node-environment-extensions/error-inspect");
+`;
+const pathFilter = getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
+    escape: false,
+});
+/**
+ * Patches to avoid pulling babel (~4MB).
+ *
+ * Details:
+ * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
+ * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
+ */
+const babelPatches = [
+    // Empty the body of `NextServer#runMiddleware`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runMiddleware\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
+        },
+    },
+    // Empty the body of `NextServer#runEdgeFunction`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runEdgeFunction\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
+        },
+    },
+    // Drop `error-inspect` that pulls babel
+    {
+        field: {
+            pathFilter,
+            contentFilter: /error-inspect/,
+            patchCode: createPatchCode(errorInspectRule),
+        },
+    },
+];
 export const patchNextServer = {
     name: "patch-next-server",
     patches: [
-        // Skip executing next middleware, edge functions and image optimization inside NextServer
+        // Empty the body of `NextServer#imageOptimizer` - unused in OpenNext
         {
-            versions: ">=15.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
-                contentFilter: /process\.env\.NEXT_MINIMAL/,
-                patchCode: createPatchCode(minimalRule),
+                pathFilter,
+                contentFilter: /imageOptimizer\(/,
+                patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
             },
         },
-        // Disable Next background preloading done at creation of `NetxServer`
+        // Disable Next background preloading done at creation of `NextServer`
         {
-            versions: ">=15.0.0",
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
                 patchCode: createPatchCode(disablePreloadingRule),
             },
         },
         // Don't match edge functions in `NextServer`
         {
-            versions: ">=15.0.0",
+            // Next 12 and some version of 13 use the bundled middleware/edge function
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /getMiddlewareManifest/,
                 patchCode: createPatchCode(removeMiddlewareManifestRule),
             },
         },
+        ...babelPatches,
     ],
 };

package/dist/core/createMainHandler.js

@@ -1,7 +1,7 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
 import { openNextHandler } from "./requestHandler";
-import { resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { resolveAssetResolver, resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
     // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
@@ -16,6 +16,9 @@ export async function createMainHandler() {
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
+    if (config.middleware?.external !== true) {
+        globalThis.assetResolver = await resolveAssetResolver(globalThis.openNextConfig.middleware?.assetResolver);
+    }
     globalThis.proxyExternalRequest = await resolveProxyRequest(thisFunction.override?.proxyExternalRequest);
     globalThis.cdnInvalidationHandler = await resolveCdnInvalidation(thisFunction.override?.cdnInvalidation);
     // From the config, we create the converter

package/dist/core/requestHandler.js

@@ -5,7 +5,7 @@ import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
-import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
@@ -14,10 +14,17 @@ patchAsyncStorage();
 //#endOverride
 export async function openNextHandler(internalEvent, options) {
     const initialHeaders = internalEvent.headers;
+    // We only use the requestId header if we are using an external middleware
+    // This is to ensure that no one can spoof the requestId
+    // When using an external middleware, we always assume that headers cannot be spoofed
+    const requestId = globalThis.openNextConfig.middleware?.external
+        ? internalEvent.headers[INTERNAL_EVENT_REQUEST_ID]
+        : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
     return runWithOpenNextRequestContext({
         isISRRevalidation: initialHeaders["x-isr"] === "1",
         waitUntil: options?.waitUntil,
+        requestId,
     }, async () => {
         await globalThis.__next_route_preloader("waitUntil");
         if (initialHeaders["x-forwarded-host"]) {
@@ -40,7 +47,9 @@ export async function openNextHandler(internalEvent, options) {
             ...internalHeaders,
         };
         //#override withRouting
-        routingResult = await routingHandler(internalEvent);
+        routingResult = await routingHandler(internalEvent, {
+            assetResolver: globalThis.assetResolver,
+        });
         //#endOverride
         const headers = "type" in routingResult
             ? routingResult.headers