initial implementation

Author: conico974

packages/open-next/src/adapters/config/index.ts

@@ -12,6 +12,7 @@ import {
   loadMiddlewareManifest,
   loadPrerenderManifest,
   loadRoutesManifest,
+  loadFunctionsConfigManifest,
 } from "./util.js";
 
 export const NEXT_DIR = path.join(__dirname, ".next");
@@ -35,3 +36,6 @@ export const MiddlewareManifest =
 export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
 export const AppPathRoutesManifest =
   /* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);
+
+export const FunctionsConfigManifest =
+  /* @__PURE__ */ loadFunctionsConfigManifest(NEXT_DIR);

packages/open-next/src/adapters/config/util.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type {
+  FunctionsConfigManifest,
   MiddlewareManifest,
   NextConfig,
   PrerenderManifest,
@@ -123,3 +124,17 @@ export function loadMiddlewareManifest(nextDir: string) {
   const json = fs.readFileSync(filePath, "utf-8");
   return JSON.parse(json) as MiddlewareManifest;
 }
+
+export function loadFunctionsConfigManifest(nextDir: string) {
+  const filePath = path.join(
+    nextDir,
+    "server",
+    "functions-config-manifest.json",
+  );
+  try {
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json) as FunctionsConfigManifest;
+  } catch (e) {
+    return;
+  }
+}

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

@@ -141,6 +141,15 @@ File ${fullFilePath} does not exist
     }
   };
 
+  if (existsSync(path.join(dotNextDir, "server/middleware.js.nft.json"))) {
+    //TODO: For now we copy the middleware.js file not from the standalone dir, this will probably be removed in the future
+    filesToCopy.set(
+      path.join(dotNextDir, "server/middleware.js"),
+      path.join(outputNextDir, "server/middleware.js"),
+    );
+    safeComputeCopyFilesForPage("middleware");
+  }
+
   const hasPageDir = routes.some((route) => route.startsWith("pages/"));
   const hasAppDir = routes.some((route) => route.startsWith("app/"));
 

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

@@ -1,8 +1,10 @@
 import fs from "node:fs";
+import fsAsync from "node:fs/promises";
 import path from "node:path";
 
 import logger from "../logger.js";
 import type {
+  FunctionsConfigManifest,
   MiddlewareInfo,
   MiddlewareManifest,
 } from "../types/next-types.js";
@@ -36,6 +38,42 @@ export async function createMiddleware(
     | MiddlewareInfo
     | undefined;
 
+  if (!middlewareInfo) {
+    // If there is no middleware info, it might be a node middleware
+    const functionsConfigManifestPath = path.join(
+      appBuildOutputPath,
+      ".next/server/functions-config-manifest.json",
+    );
+    const functionsConfigManifest = JSON.parse(
+      await fsAsync
+        .readFile(functionsConfigManifestPath, "utf8")
+        .catch(() => "{}"),
+    ) as FunctionsConfigManifest;
+
+    // TODO: Handle external node middleware in the future
+    if (functionsConfigManifest?.functions["/_middleware"]) {
+      // If we are here, it means that we are using a node middleware
+      await buildHelper.esbuildAsync(
+        {
+          entryPoints: [
+            path.join(
+              options.openNextDistDir,
+              "core",
+              "nodeMiddlewareHandler.js",
+            ),
+          ],
+          external: ["./.next/*"],
+          outfile: path.join(options.buildDir, "middleware.mjs"),
+          bundle: true,
+          platform: "node",
+        },
+        options,
+      );
+      // We return early to not build the edge middleware
+      return;
+    }
+  }
+
   if (config.middleware?.external) {
     const outputPath = path.join(outputDir, "middleware");
     fs.mkdirSync(outputPath, { recursive: true });

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

@@ -28,6 +28,7 @@ export default async function edgeFunctionHandler(
       },
     },
   });
+  // TODO: use the global waitUntil
   await result.waitUntil;
   const response = result.response;
   return response;

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

@@ -0,0 +1,47 @@
+import type { RequestData } from "types/global";
+
+type EdgeRequest = Omit<RequestData, "page">;
+
+// Do we need Buffer here?
+import { Buffer } from "node:buffer";
+globalThis.Buffer = Buffer;
+
+// AsyncLocalStorage is needed to be defined globally
+import { AsyncLocalStorage } from "node:async_hooks";
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+
+interface NodeMiddleware {
+  default: (req: {
+    handler: any;
+    request: EdgeRequest;
+    page: "middleware";
+  }) => Promise<{
+    response: Response;
+    waitUntil: Promise<void>;
+  }>;
+  middleware: any;
+}
+
+let _module: NodeMiddleware | undefined;
+
+export default async function middlewareHandler(
+  request: EdgeRequest,
+): Promise<Response> {
+  if (!_module) {
+    // We use await import here so that we are sure that it is loaded after AsyncLocalStorage is defined on globalThis
+    // TODO: We will probably need to change this at build time when used in a monorepo (or if the location changes)
+    //@ts-expect-error - This file should be bundled with esbuild
+    _module = (await import("./.next/server/middleware.js")).default;
+  }
+  const adapterFn = _module!.default || _module;
+  const result = await adapterFn({
+    handler: _module!.middleware || _module,
+    request: request,
+    page: "middleware",
+  });
+  // Not sure if we should await it here or defer to the global als
+  globalThis.__openNextAls
+    .getStore()
+    ?.pendingPromiseRunner.add(result.waitUntil);
+  return result.response;
+}

packages/open-next/src/core/routing/middleware.ts

@@ -1,6 +1,10 @@
 import type { ReadableStream } from "node:stream/web";
 
-import { MiddlewareManifest, NextConfig } from "config/index.js";
+import {
+  FunctionsConfigManifest,
+  MiddlewareManifest,
+  NextConfig,
+} from "config/index.js";
 import type { InternalEvent, InternalResult } from "types/open-next.js";
 import { emptyReadableStream } from "utils/stream.js";
 
@@ -20,8 +24,12 @@ import {
 } from "./util.js";
 
 const middlewareManifest = MiddlewareManifest;
+const functionsConfigManifest = FunctionsConfigManifest;
 
-const middleMatch = getMiddlewareMatch(middlewareManifest);
+const middleMatch = getMiddlewareMatch(
+  middlewareManifest,
+  functionsConfigManifest,
+);
 
 type MiddlewareEvent = InternalEvent & {
   responseHeaders?: Record<string, string | string[]>;

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

@@ -6,7 +6,10 @@ import { BuildId, HtmlPages, NextConfig } from "config/index.js";
 import type { IncomingMessage } from "http/index.js";
 import { OpenNextNodeResponse } from "http/openNextResponse.js";
 import { parseHeaders } from "http/util.js";
-import type { MiddlewareManifest } from "types/next-types";
+import type {
+  FunctionsConfigManifest,
+  MiddlewareManifest,
+} from "types/next-types";
 import type {
   InternalEvent,
   InternalResult,
@@ -142,7 +145,17 @@ export function convertToQuery(querystring: string) {
  *
  * @__PURE__
  */
-export function getMiddlewareMatch(middlewareManifest: MiddlewareManifest) {
+export function getMiddlewareMatch(
+  middlewareManifest: MiddlewareManifest,
+  functionsManifest?: FunctionsConfigManifest,
+) {
+  if (functionsManifest) {
+    return (
+      functionsManifest.functions["/_middleware"].matchers?.map(
+        ({ regexp }) => new RegExp(regexp),
+      ) ?? [/.*/]
+    );
+  }
   const rootMiddleware = middlewareManifest.middleware["/"];
   if (!rootMiddleware?.matchers) return [];
   return rootMiddleware.matchers.map(({ regexp }) => new RegExp(regexp));

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

@@ -178,3 +178,20 @@ export type PluginHandler = (
   res: OpenNextNodeResponse,
   options: Options,
 ) => Promise<OpenNextNodeResponse | undefined>;
+
+export interface FunctionsConfigManifest {
+  version: number;
+  functions: Record<
+    string,
+    {
+      maxDuration?: number | undefined;
+      runtime?: "nodejs";
+      matchers?: Array<{
+        regexp: string;
+        originalSource: string;
+        has?: Rewrite["has"];
+        missing?: Rewrite["has"];
+      }>;
+    }
+  >;
+}