[wip] Feat/node middleware support

.github/workflows/run-tests.yml

@@ -38,7 +38,7 @@ jobs:
           elif [ "${{ github.event_name }}" = "schedule" ] || [ "${{ steps.check-labels.outputs.result }}" = "true" ]; then
             echo "matrix=[\"latest\", \"canary\", \"14.2.15\", \"13.5.1\"]" >> $GITHUB_OUTPUT
           else
-            echo "matrix=[\"latest\"]" >> $GITHUB_OUTPUT
+            echo "matrix=[\"latest\",\"canary\"]" >> $GITHUB_OUTPUT
           fi
 
   e2e:

.gitignore

@@ -1,6 +1,7 @@
 node_modules/
 dist/
 .next
+.next-node-middleware
 edge-runtime/vendor
 # deno.json is ephemeral and generated for the purpose of vendoring remote modules in CI
 tools/deno/deno.json

edge-runtime/lib/cjs.ts

@@ -0,0 +1,122 @@
+import { Module, createRequire } from 'node:module'
+import vm from 'node:vm'
+import { join, dirname } from 'node:path/posix'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+type RegisteredModule = {
+  source: string
+  loaded: boolean
+  filename: string
+}
+const registeredModules = new Map<string, RegisteredModule>()
+
+const require = createRequire(import.meta.url)
+
+let hookedIn = false
+
+function seedCJSModuleCacheAndReturnTarget(matchedModule: RegisteredModule, parent: Module) {
+  if (matchedModule.loaded) {
+    return matchedModule.filename
+  }
+  const { source, filename } = matchedModule
+
+  const mod = new Module(filename)
+  mod.parent = parent
+  mod.filename = filename
+  mod.path = dirname(filename)
+  // @ts-expect-error - private untyped API
+  mod.paths = Module._nodeModulePaths(mod.path)
+  require.cache[filename] = mod
+
+  const wrappedSource = `(function (exports, require, module, __filename, __dirname) { ${source}\n});`
+  try {
+    const compiled = vm.runInThisContext(wrappedSource, {
+      filename,
+      lineOffset: 0,
+      displayErrors: true,
+    })
+    compiled(mod.exports, createRequire(pathToFileURL(filename)), mod, filename, dirname(filename))
+    mod.loaded = matchedModule.loaded = true
+  } catch (error) {
+    throw new Error(`Failed to compile CJS module: ${filename}`, { cause: error })
+  }
+
+  return filename
+}
+
+const exts = ['.js', '.cjs', '.json']
+
+function tryWithExtensions(filename: string) {
+  let matchedModule = registeredModules.get(filename)
+  if (!matchedModule) {
+    for (const ext of exts) {
+      // require("./test") might resolve to ./test.js
+      const targetWithExt = filename + ext
+
+      matchedModule = registeredModules.get(targetWithExt)
+      if (matchedModule) {
+        break
+      }
+    }
+  }
+
+  return matchedModule
+}
+
+function tryMatchingWithIndex(target: string) {
+  let matchedModule = tryWithExtensions(target)
+  if (!matchedModule) {
+    // require("./test") might resolve to ./test/index.js
+    const indexTarget = join(target, 'index')
+    matchedModule = tryWithExtensions(indexTarget)
+  }
+
+  return matchedModule
+}
+
+export function registerCJSModules(baseUrl: URL, modules: Map<string, string>) {
+  const basePath = dirname(fileURLToPath(baseUrl))
+
+  for (const [filename, source] of modules.entries()) {
+    const target = join(basePath, filename)
+
+    registeredModules.set(target, { source, loaded: false, filename: target })
+  }
+
+  if (!hookedIn) {
+    // @ts-expect-error - private untyped API
+    const original_resolveFilename = Module._resolveFilename.bind(Module)
+    // @ts-expect-error - private untyped API
+    Module._resolveFilename = (...args) => {
+      let target = args[0]
+      let isRelative = args?.[0].startsWith('.')
+
+      if (isRelative) {
+        // only handle relative require paths
+        const requireFrom = args?.[1]?.filename
+
+        target = join(dirname(requireFrom), args[0])
+      }
+
+      let matchedModule = tryMatchingWithIndex(target)
+
+      if (!isRelative && !target.startsWith('/')) {
+        for (const nodeModulePaths of args[1].paths) {
+          const potentialPath = join(nodeModulePaths, target)
+          matchedModule = tryMatchingWithIndex(potentialPath)
+          if (matchedModule) {
+            break
+          }
+        }
+      }
+
+      if (matchedModule) {
+        return seedCJSModuleCacheAndReturnTarget(matchedModule, args[1])
+      }
+
+      return original_resolveFilename(...args)
+    }
+
+    hookedIn = true
+  }
+}

edge-runtime/shim/node.js

@@ -0,0 +1,16 @@
+// NOTE: This is a fragment of a JavaScript program that will be inlined with
+// a Webpack bundle. You should not import this file from anywhere in the
+// application.
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+import { createRequire } from 'node:module' // used in dynamically generated part
+import process from 'node:process'
+
+import { registerCJSModules } from '../edge-runtime/lib/cjs.ts' // used in dynamically generated part
+
+globalThis.process = process
+
+globalThis.AsyncLocalStorage = AsyncLocalStorage
+
+// needed for path.relative and path.resolve to work
+Deno.cwd = () => ''

src/build/content/server.ts

@@ -133,7 +133,13 @@ export const copyNextServerCode = async (ctx: PluginContext): Promise<void> => {
         }
 
         if (path === 'server/functions-config-manifest.json') {
-          await verifyFunctionsConfigManifest(join(srcDir, path))
+          try {
+            await replaceFunctionsConfigManifest(srcPath, destPath)
+          } catch (error) {
+            throw new Error('Could not patch functions config manifest file', { cause: error })
+          }
+
+          return
         }
 
         await cp(srcPath, destPath, { recursive: true, force: true })
@@ -381,19 +387,41 @@ const replaceMiddlewareManifest = async (sourcePath: string, destPath: string) =
   await writeFile(destPath, newData)
 }
 
-const verifyFunctionsConfigManifest = async (sourcePath: string) => {
+// similar to the middleware manifest, we need to patch the functions config manifest to disable
+// the middleware that is defined in the functions config manifest. This is needed to avoid running
+// the middleware in the server handler, while still allowing next server to enable some middleware
+// specific handling such as _next/data normalization ( https://github.com/vercel/next.js/blob/7bb72e508572237fe0d4aac5418546d4b4b3a363/packages/next/src/server/lib/router-utils/resolve-routes.ts#L395 )
+const replaceFunctionsConfigManifest = async (sourcePath: string, destPath: string) => {
   const data = await readFile(sourcePath, 'utf8')
   const manifest = JSON.parse(data) as FunctionsConfigManifest
 
   // https://github.com/vercel/next.js/blob/8367faedd61501025299e92d43a28393c7bb50e2/packages/next/src/build/index.ts#L2465
   // Node.js Middleware has hardcoded /_middleware path
-  if (manifest.functions['/_middleware']) {
-    throw new Error(
-      'Node.js middleware is not yet supported.\n\n' +
-        'Future @netlify/plugin-nextjs release will support node middleware with following limitations:\n' +
-        ' - usage of C++ Addons (https://nodejs.org/api/addons.html) not supported (for example `bcrypt` npm module will not be supported, but `bcryptjs` will be supported),\n' +
-        ' - usage of Filesystem (https://nodejs.org/api/fs.html) not supported.',
-    )
+  if (manifest?.functions?.['/_middleware']?.matchers) {
+    const newManifest = {
+      ...manifest,
+      functions: {
+        ...manifest.functions,
+        '/_middleware': {
+          ...manifest.functions['/_middleware'],
+          matchers: manifest.functions['/_middleware'].matchers.map((matcher) => {
+            return {
+              ...matcher,
+              // matcher that won't match on anything
+              // this is meant to disable actually running middleware in the server handler,
+              // while still allowing next server to enable some middleware specific handling
+              // such as _next/data normalization ( https://github.com/vercel/next.js/blob/7bb72e508572237fe0d4aac5418546d4b4b3a363/packages/next/src/server/lib/router-utils/resolve-routes.ts#L395 )
+              regexp: '(?!.*)',
+            }
+          }),
+        },
+      },
+    }
+    const newData = JSON.stringify(newManifest)
+
+    await writeFile(destPath, newData)
+  } else {
+    await cp(sourcePath, destPath, { recursive: true, force: true })
   }
 }