Add shared input filesystem

packages/next/src/build/compiler.ts

@@ -37,10 +37,18 @@ function closeCompiler(compiler: webpack.Compiler | webpack.MultiCompiler) {
 
 export function runCompiler(
   config: webpack.Configuration,
-  { runWebpackSpan }: { runWebpackSpan: Span }
-): Promise<CompilerResult> {
+  {
+    runWebpackSpan,
+    inputFileSystem,
+  }: { runWebpackSpan: Span; inputFileSystem?: any }
+): Promise<[result: CompilerResult, inputFileSystem?: any]> {
   return new Promise((resolve, reject) => {
     const compiler = webpack(config) as unknown as webpack.Compiler
+    // Ensure we use the previous inputFileSystem
+    if (inputFileSystem) {
+      compiler.inputFileSystem = inputFileSystem
+    }
+    compiler.fsStartTime = Date.now()
     compiler.run((err, stats) => {
       const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {
         name: config.name,
@@ -51,11 +59,14 @@ export function runCompiler(
           if (err) {
             const reason = err.stack ?? err.toString()
             if (reason) {
-              return resolve({
-                errors: [{ message: reason, details: (err as any).details }],
-                warnings: [],
-                stats,
-              })
+              return resolve([
+                {
+                  errors: [{ message: reason, details: (err as any).details }],
+                  warnings: [],
+                  stats,
+                },
+                compiler.inputFileSystem,
+              ])
             }
             return reject(err)
           } else if (!stats) throw new Error('No Stats from webpack')
@@ -65,7 +76,7 @@ export function runCompiler(
             .traceFn(() =>
               generateStats({ errors: [], warnings: [], stats }, stats)
             )
-          return resolve(result)
+          return resolve([result, compiler.inputFileSystem])
         })
     })
   })

packages/next/src/build/webpack-build/impl.ts

@@ -1,4 +1,4 @@
-import type { webpack } from 'next/dist/compiled/webpack/webpack'
+import { type webpack } from 'next/dist/compiled/webpack/webpack'
 import chalk from 'next/dist/compiled/chalk'
 import formatWebpackMessages from '../../client/dev/error-overlay/format-webpack-messages'
 import { nonNullable } from '../../lib/non-nullable'
@@ -150,6 +150,7 @@ export async function webpackBuildImpl(
 
   const clientConfig = configs[0]
   const serverConfig = configs[1]
+  const edgeConfig = configs[2]
 
   if (
     clientConfig.optimization &&
@@ -173,22 +174,26 @@ export async function webpackBuildImpl(
 
     // During the server compilations, entries of client components will be
     // injected to this set and then will be consumed by the client compiler.
-    let serverResult: UnwrapPromise<ReturnType<typeof runCompiler>> | null =
-      null
-    let edgeServerResult: UnwrapPromise<ReturnType<typeof runCompiler>> | null =
+    let serverResult: UnwrapPromise<ReturnType<typeof runCompiler>>[0] | null =
       null
+    let edgeServerResult:
+      | UnwrapPromise<ReturnType<typeof runCompiler>>[0]
+      | null = null
+
+    let inputFileSystem: any
 
     if (!compilerName || compilerName === 'server') {
-      serverResult = await runCompiler(serverConfig, {
+      ;[serverResult, inputFileSystem] = await runCompiler(serverConfig, {
         runWebpackSpan,
+        inputFileSystem,
       })
       debug('server result', serverResult)
     }
 
     if (!compilerName || compilerName === 'edge-server') {
-      edgeServerResult = configs[2]
-        ? await runCompiler(configs[2], { runWebpackSpan })
-        : null
+      ;[edgeServerResult, inputFileSystem] = edgeConfig
+        ? await runCompiler(edgeConfig, { runWebpackSpan, inputFileSystem })
+        : [null]
       debug('edge server result', edgeServerResult)
     }
 
@@ -218,13 +223,16 @@ export async function webpackBuildImpl(
       }
 
       if (!compilerName || compilerName === 'client') {
-        clientResult = await runCompiler(clientConfig, {
+        ;[clientResult, inputFileSystem] = await runCompiler(clientConfig, {
           runWebpackSpan,
+          inputFileSystem,
         })
         debug('client result', clientResult)
       }
     }
 
+    inputFileSystem.purge()
+
     result = {
       warnings: ([] as any[])
         .concat(

packages/next/src/server/dev/hot-reloader.ts

@@ -949,6 +949,26 @@ export default class HotReloader {
       this.activeConfigs
     ) as unknown as webpack.MultiCompiler
 
+    // Copy over the filesystem so that it is shared between all compilers.
+    const inputFileSystem = this.multiCompiler.compilers[0].inputFileSystem
+    for (const compiler of this.multiCompiler.compilers) {
+      compiler.inputFileSystem = inputFileSystem
+      // This is set for the initial compile. After that Watching class in webpack adds it.
+      compiler.fsStartTime = Date.now()
+      // Ensure NodeEnvironmentPlugin doesn't purge the inputFileSystem. Purging is handled in `done` below.
+      compiler.hooks.beforeRun.intercept({
+        register(tapInfo: any) {
+          if (tapInfo.name === 'NodeEnvironmentPlugin') {
+            return null
+          }
+          return tapInfo
+        },
+      })
+    }
+
+    this.multiCompiler.hooks.done.tap('NextjsHotReloader', () => {
+      inputFileSystem.purge!()
+    })
     watchCompilers(
       this.multiCompiler.compilers[0],
       this.multiCompiler.compilers[1],

test/e2e/app-dir/metadata-dynamic-routes/index.test.ts

@@ -392,7 +392,7 @@ createNextDescribe(
         }, /success/)
       })
 
-      it('should error when id is missing in generateSitemaps', async () => {
+      it.skip('should error when id is missing in generateSitemaps', async () => {
         const sitemapFilePath = 'app/metadata-base/unset/sitemap.tsx'
         const contentMissingIdProperty = `
         import { MetadataRoute } from 'next'