Improve Perf

.changeset/warm-pans-argue.md

@@ -0,0 +1,8 @@
+---
+"@opennextjs/aws": patch
+---
+
+Some perf improvements : 
+- Eliminate unnecessary runtime imports (i.e. dev react dependencies and next precompiled dev or turbopack dependencies)
+- Refactor route preloading to be either on-demand or using waitUntil or at the start or during warmerEvent.
+- Add a global function to preload routes when needed.

packages/open-next/src/build/createServerBundle.ts

@@ -18,10 +18,12 @@ import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { type CodePatcher, applyCodePatches } from "./patch/codePatcher.js";
 import {
+  patchEnvVars,
   patchFetchCacheForISR,
+  patchFetchCacheSetMissingWaitUntil,
+  patchNextServer,
   patchUnstableCacheForISR,
-} from "./patch/patchFetchCacheISR.js";
-import { patchFetchCacheSetMissingWaitUntil } from "./patch/patchFetchCacheWaitUntil.js";
+} from "./patch/patches/index.js";
 
 interface CodeCustomization {
   // These patches are meant to apply on user and next generated code
@@ -187,6 +189,8 @@ async function generateBundle(
     patchFetchCacheSetMissingWaitUntil,
     patchFetchCacheForISR,
     patchUnstableCacheForISR,
+    patchNextServer,
+    patchEnvVars,
     ...additionalCodePatches,
   ]);
 

packages/open-next/src/build/patch/patches/index.ts

@@ -0,0 +1,7 @@
+export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
+export { patchNextServer } from "./patchNextServer.js";
+export {
+  patchFetchCacheForISR,
+  patchUnstableCacheForISR,
+} from "./patchFetchCacheISR.js";
+export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";

packages/open-next/src/build/patch/patches/patchEnvVar.ts

@@ -0,0 +1,58 @@
+import { createPatchCode } from "../astCodePatcher.js";
+import type { CodePatcher } from "../codePatcher";
+
+/**
+ * Creates a rule to replace `process.env.${envVar}` by `value` in the condition of if statements
+ * This is used to avoid loading unnecessary deps at runtime
+ * @param envVar The env var that we want to replace
+ * @param value The value that we want to replace it with
+ * @returns
+ */
+export const envVarRuleCreator = (envVar: string, value: string) => `
+rule:
+  kind: member_expression
+  pattern: process.env.${envVar}
+  inside:
+    kind: parenthesized_expression
+    stopBy: end
+    inside:
+      kind: if_statement
+fix:
+  '${value}'
+`;
+
+export const patchEnvVars: CodePatcher = {
+  name: "patch-env-vars",
+  patches: [
+    // This patch will set the `NEXT_RUNTIME` env var to "node" to avoid loading unnecessary edge deps at runtime
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter: /module\.compiled\.js$/,
+        contentFilter: /process\.env\.NEXT_RUNTIME/,
+        patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
+      },
+    },
+    // This patch will set `NODE_ENV` to production to avoid loading unnecessary dev deps at runtime
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter:
+          /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
+        contentFilter: /process\.env\.NODE_ENV/,
+        patchCode: createPatchCode(
+          envVarRuleCreator("NODE_ENV", '"production"'),
+        ),
+      },
+    },
+    // This patch will set `TURBOPACK` env to false to avoid loading turbopack related deps at runtime
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter: /module\.compiled\.js$/,
+        contentFilter: /process\.env\.TURBOPACK/,
+        patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
+      },
+    },
+  ],
+};

packages/open-next/src/build/patch/patchFetchCacheISR.ts → packages/open-next/src/build/patch/patches/patchFetchCacheISR.ts

@@ -1,7 +1,7 @@
 import { Lang } from "@ast-grep/napi";
 import { getCrossPlatformPathRegex } from "utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
-import type { CodePatcher } from "./codePatcher";
+import { createPatchCode } from "../astCodePatcher.js";
+import type { CodePatcher } from "../codePatcher.js";
 
 export const fetchRule = `
 rule:

packages/open-next/src/build/patch/patchFetchCacheWaitUntil.ts → packages/open-next/src/build/patch/patches/patchFetchCacheWaitUntil.ts

@@ -1,6 +1,6 @@
 import { getCrossPlatformPathRegex } from "utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
-import type { CodePatcher } from "./codePatcher";
+import { createPatchCode } from "../astCodePatcher.js";
+import type { CodePatcher } from "../codePatcher.js";
 
 export const rule = `
 rule:

packages/open-next/src/build/patch/patches/patchNextServer.ts

@@ -0,0 +1,96 @@
+import { createPatchCode } from "../astCodePatcher.js";
+import type { CodePatcher } from "../codePatcher.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
+export const disablePreloadingRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: if_statement
+    any: 
+      - has: 
+          kind: member_expression
+          pattern: this.nextConfig.experimental.preloadEntriesOnStart
+          stopBy: end
+      - 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
+export const removeMiddlewareManifestRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: method_definition
+    has:
+      kind: property_identifier
+      regex: getMiddlewareManifest
+fix:
+  '{return null;}'
+`;
+
+export const patchNextServer: CodePatcher = {
+  name: "patch-next-server",
+  patches: [
+    // Skip executing next middleware, edge functions and image optimization inside NextServer
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter: /next-server\.(js)$/,
+        contentFilter: /process\.env\.NEXT_MINIMAL/,
+        patchCode: createPatchCode(minimalRule),
+      },
+    },
+    // Disable Next background preloading done at creation of `NetxServer`
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter: /next-server\.(js)$/,
+        contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
+        patchCode: createPatchCode(disablePreloadingRule),
+      },
+    },
+    // Don't match edge functions in `NextServer`
+    {
+      versions: ">=15.0.0",
+      field: {
+        pathFilter: /next-server\.(js)$/,
+        contentFilter: /getMiddlewareManifest/,
+        patchCode: createPatchCode(removeMiddlewareManifestRule),
+      },
+    },
+  ],
+};

packages/open-next/src/core/createMainHandler.ts

@@ -26,6 +26,9 @@ export async function createMainHandler() {
   globalThis.serverId = generateUniqueId();
   globalThis.openNextConfig = config;
 
+  // If route preloading behavior is set to start, it will wait for every single route to be preloaded before even creating the main handler.
+  await globalThis.__next_route_preloader("start");
+
   // Default queue
   globalThis.queue = await resolveQueue(thisFunction.override?.queue);
 

packages/open-next/src/core/requestHandler.ts

@@ -47,6 +47,7 @@ export async function openNextHandler(
       waitUntil: options?.waitUntil,
     },
     async () => {
+      await globalThis.__next_route_preloader("waitUntil");
       if (initialHeaders["x-forwarded-host"]) {
         initialHeaders.host = initialHeaders["x-forwarded-host"];
       }

packages/open-next/src/core/util.ts

@@ -6,7 +6,7 @@ import {
 // @ts-ignore
 import NextServer from "next/dist/server/next-server.js";
 
-import { debug } from "../adapters/logger.js";
+import { debug, error } from "../adapters/logger.js";
 import {
   applyOverride as applyNextjsRequireHooksOverride,
   overrideHooks as overrideNextjsRequireHooks,
@@ -59,6 +59,53 @@ const nextServer = new NextServer.default({
   dir: __dirname,
 });
 
+let routesLoaded = false;
+
+globalThis.__next_route_preloader = async (stage) => {
+  if (routesLoaded) {
+    return;
+  }
+  const thisFunction = globalThis.fnName
+    ? globalThis.openNextConfig.functions![globalThis.fnName]
+    : globalThis.openNextConfig.default;
+  const routePreloadingBehavior =
+    thisFunction?.routePreloadingBehavior ?? "none";
+  if (routePreloadingBehavior === "none") {
+    routesLoaded = true;
+    return;
+  }
+  if (!("unstable_preloadEntries" in nextServer)) {
+    debug(
+      "The current version of Next.js does not support route preloading. Skipping route preloading.",
+    );
+    routesLoaded = true;
+    return;
+  }
+  if (stage === "waitUntil" && routePreloadingBehavior === "withWaitUntil") {
+    // We need to access the waitUntil
+    const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+    if (!waitUntil) {
+      error(
+        "You've tried to use the 'withWaitUntil' route preloading behavior, but the 'waitUntil' function is not available.",
+      );
+      routesLoaded = true;
+      return;
+    }
+    debug("Preloading entries with waitUntil");
+    waitUntil?.(nextServer.unstable_preloadEntries());
+    routesLoaded = true;
+  } else if (
+    (stage === "start" && routePreloadingBehavior === "onStart") ||
+    (stage === "warmerEvent" && routePreloadingBehavior === "onWarmerEvent") ||
+    stage === "onDemand"
+  ) {
+    const startTimestamp = Date.now();
+    debug("Preloading entries");
+    await nextServer.unstable_preloadEntries();
+    debug("Preloading entries took", Date.now() - startTimestamp, "ms");
+    routesLoaded = true;
+  }
+};
 // `getRequestHandlerWithMetadata` is not available in older versions of Next.js
 // It is required to for next 15.2 to pass metadata for page router data route
 export const requestHandler = (metadata: Record<string, any>) =>

packages/open-next/src/overrides/wrappers/aws-lambda-streaming.ts

@@ -35,6 +35,7 @@ const handler: WrapperHandler = async (handler, converter) =>
       if ("type" in event) {
         const result = await formatWarmerResponse(event);
         responseStream.end(Buffer.from(JSON.stringify(result)), "utf-8");
+        await globalThis.__next_route_preloader("warmerEvent");
         return;
       }
 

packages/open-next/src/types/global.ts

@@ -211,4 +211,13 @@ declare global {
    * Defined in `createMainHandler`
    */
   var cdnInvalidationHandler: CDNInvalidationHandler;
+
+  /**
+   * A function to preload the routes.
+   * This needs to be defined on globalThis because it can be used by custom overrides.
+   * Only available in main functions.
+   */
+  var __next_route_preloader: (
+    stage: "waitUntil" | "start" | "warmerEvent" | "onDemand",
+  ) => Promise<void>;
 }

packages/open-next/src/types/open-next.ts

@@ -118,6 +118,21 @@ export interface ResolvedRoute {
   type: RouteType;
 }
 
+/**
+ * The route preloading behavior. Only supported in Next 15+.
+ * Default behavior of Next is disabled. You should do your own testing to choose which one suits you best
+ * - "none" - No preloading of the route at all. This is the default
+ * - "withWaitUntil" - Preload the route using the waitUntil provided by the wrapper - If not supported, it will fallback to "none". At the moment only cloudflare wrappers provide a `waitUntil`
+ * - "onWarmerEvent" - Preload the route on the warmer event - Needs to be implemented by the wrapper. Only supported in `aws-lambda-streaming` wrapper for now
+ * - "onStart" - Preload the route before even invoking the wrapper - This is a blocking operation. The handler will only be created after all the routes have been loaded, it may increase the cold start time by a lot in some cases. Useful for long running server or in serverless with some careful testing
+ * @default "none"
+ */
+export type RoutePreloadingBehavior =
+  | "none"
+  | "withWaitUntil"
+  | "onWarmerEvent"
+  | "onStart";
+
 export interface RoutingResult {
   internalEvent: InternalEvent;
   // If the request is an external rewrite, if used with an external middleware will be false on every server function
@@ -170,7 +185,6 @@ export type IncludedWarmer = "aws-lambda" | "dummy";
 export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
 
 export type IncludedCDNInvalidationHandler = "cloudfront" | "dummy";
-
 export interface DefaultOverrideOptions<
   E extends BaseEventOrResult = InternalEvent,
   R extends BaseEventOrResult = InternalResult,
@@ -313,6 +327,8 @@ export interface FunctionOptions extends DefaultFunctionOptions {
    * @deprecated This is not supported in 14.2+
    */
   experimentalBundledNextServer?: boolean;
+
+  routePreloadingBehavior?: RoutePreloadingBehavior;
 }
 
 export type RouteTemplate =