fix: fixes the runtime inside monorepos like turborepo (#204)

* fix: fixes the runtime inside monorepos like turborepo

* chore: update

* chore: pr feedback

Author: lukasholzer

src/build/content/server.ts

@@ -10,7 +10,7 @@ import { PluginContext } from '../plugin-context.js'
  * Copy App/Pages Router Javascript needed by the server handler
  */
 export const copyNextServerCode = async (ctx: PluginContext): Promise<void> => {
-  const srcDir = join(ctx.publishDir, 'standalone/.next')
+  const srcDir = join(ctx.standaloneDir, '.next')
   const destDir = join(ctx.serverHandlerDir, '.next')
 
   const paths = await glob(
@@ -81,27 +81,39 @@ async function recreateNodeModuleSymlinks(src: string, dest: string, org?: strin
 }
 
 export const copyNextDependencies = async (ctx: PluginContext): Promise<void> => {
-  const entries = await readdir(join(ctx.publishDir, 'standalone'))
+  const entries = await readdir(ctx.standaloneDir)
+  const promises: Promise<void>[] = entries.map(async (entry) => {
+    // copy all except the package.json and .next folder as this is handled in a separate function
+    // this will include the node_modules folder as well
+    if (entry === 'package.json' || entry === '.next') {
+      return
+    }
+    const src = join(ctx.standaloneDir, entry)
+    const dest = join(ctx.serverHandlerDir, entry)
+    await cp(src, dest, { recursive: true })
 
-  await Promise.all(
-    entries.map(async (entry) => {
-      if (entry === 'package.json' || entry === '.next') {
-        return
-      }
-      const src = join(ctx.publishDir, 'standalone', entry)
-      const dest = join(ctx.serverHandlerDir, entry)
-      await cp(src, dest, { recursive: true })
-    }),
-  )
+    if (entry === 'node_modules') {
+      await recreateNodeModuleSymlinks(ctx.resolve('node_modules'), dest)
+    }
+  })
+
+  // inside a monorepo there is a root `node_modules` folder that contains all the dependencies
+  const rootSrcDir = join(ctx.standaloneRootDir, 'node_modules')
+  const rootDestDir = join(ctx.serverHandlerRootDir, 'node_modules')
 
   // TODO: @Lukas Holzer test this in monorepos
   // use the node_modules tree from the process.cwd() and not the one from the standalone output
   // as the standalone node_modules are already wrongly assembled by Next.js.
   // see: https://github.com/vercel/next.js/issues/50072
-  await recreateNodeModuleSymlinks(
-    ctx.resolve('node_modules'),
-    join(ctx.serverHandlerDir, 'node_modules'),
-  )
+  if (existsSync(rootSrcDir) && ctx.standaloneRootDir !== ctx.standaloneDir) {
+    promises.push(
+      cp(rootSrcDir, rootDestDir, { recursive: true }).then(() =>
+        recreateNodeModuleSymlinks(ctx.resolve('node_modules'), rootDestDir),
+      ),
+    )
+  }
+
+  await Promise.all(promises)
 }
 
 export const writeTagsManifest = async (ctx: PluginContext): Promise<void> => {

src/build/functions/edge.ts

@@ -79,7 +79,7 @@ const writeHandlerFile = async (ctx: PluginContext, { matchers, name }: NextDefi
 
 const copyHandlerDependencies = async (ctx: PluginContext, { name, files }: NextDefinition) => {
   const edgeRuntimePath = join(ctx.pluginDir, 'edge-runtime')
-  const srcDir = ctx.resolve('.next/standalone/.next')
+  const srcDir = join(ctx.standaloneDir, '.next')
   const shimPath = join(edgeRuntimePath, 'shim/index.js')
   const shim = await readFile(shimPath, 'utf8')
   const imports = `import './edge-runtime-webpack.js';`

src/build/functions/server.ts

@@ -17,14 +17,15 @@ const copyHandlerDependencies = async (ctx: PluginContext) => {
 
 const writeHandlerManifest = async (ctx: PluginContext) => {
   await writeFile(
-    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.json`),
+    join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.json`),
     JSON.stringify({
       config: {
         name: 'Next.js Server Handler',
         generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
         nodeBundler: 'none',
+        // the folders can vary in monorepos based on the folder structure of the user so we have to glob all
         includedFiles: ['**'],
-        includedFilesBasePath: ctx.serverHandlerDir,
+        includedFilesBasePath: ctx.serverHandlerRootDir,
       },
       version: 1,
     }),
@@ -33,21 +34,44 @@ const writeHandlerManifest = async (ctx: PluginContext) => {
 }
 
 const writePackageMetadata = async (ctx: PluginContext) => {
-  await writeFile(join(ctx.serverHandlerDir, 'package.json'), JSON.stringify({ type: 'module' }))
+  await writeFile(
+    join(ctx.serverHandlerRootDir, 'package.json'),
+    JSON.stringify({ type: 'module' }),
+  )
+}
+
+/** Get's the content of the handler file that will be written to the lambda */
+const getHandlerFile = (ctx: PluginContext): string => {
+  const config = `
+export const config = {
+  path: '/*',
+  preferStatic: true,
+}`
+
+  // In this case it is a monorepo and we need to change the process working directory
+  if (ctx.packagePath.length !== 0) {
+    return `process.chdir('${join('/var/task', ctx.packagePath)}');
+
+let cachedHandler;
+export default async function(...args) {
+  if (!cachedHandler) {
+    const { default: handler } = await import('./${ctx.nextServerHandler}');
+    cachedHandler = handler;
+  }
+  return cachedHandler(...args)
+};
+
+${config}`
+  }
+
+  // in non monorepo scenarios we don't have to change the process working directory
+  return `import handler from './dist/run/handlers/server.js';
+export default handler;
+${config}`
 }
 
 const writeHandlerFile = async (ctx: PluginContext) => {
-  await writeFile(
-    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.js`),
-    `
-    import handler from './dist/run/handlers/server.js';
-    export default handler;
-    export const config = {
-      path: '/*',
-      preferStatic: true
-    };
-    `,
-  )
+  await writeFile(join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.mjs`), getHandlerFile(ctx))
 }
 
 /**

src/build/plugin-context.ts

@@ -71,6 +71,27 @@ export class PluginContext {
     return resolve(this.constants.PUBLISH_DIR)
   }
 
+  /**
+   * Relative package path in non monorepo setups this is an empty string
+   * @example ''
+   * @example 'apps/my-app'
+   */
+  get packagePath(): string {
+    return this.constants.PACKAGE_PATH || ''
+  }
+
+  /**
+   * Retrieves the root of the `.next/standalone` directory
+   */
+  get standaloneRootDir(): string {
+    return join(this.publishDir, 'standalone')
+  }
+
+  /** Retrieves the `.next/standalone/` directory monorepo aware */
+  get standaloneDir(): string {
+    return join(this.standaloneRootDir, this.constants.PACKAGE_PATH || '')
+  }
+
   /**
    * Absolute path of the directory that is published and deployed to the Netlify CDN
    * Will be swapped with the publish directory
@@ -97,10 +118,18 @@ export class PluginContext {
   }
 
   /** Absolute path of the server handler */
-  get serverHandlerDir(): string {
+  get serverHandlerRootDir(): string {
     return join(this.serverFunctionsDir, SERVER_HANDLER_NAME)
   }
 
+  get serverHandlerDir(): string {
+    return join(this.serverHandlerRootDir, this.constants.PACKAGE_PATH || '')
+  }
+
+  get nextServerHandler(): string {
+    return join(this.constants.PACKAGE_PATH || '', 'dist/run/handlers/server.js')
+  }
+
   /**
    * Absolute path of the directory containing the files for deno edge functions
    * `.netlify/edge-functions`

src/run/config.ts

@@ -1,5 +1,6 @@
+import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 
 import type { NextConfigComplete } from 'next/dist/server/config-shared.js'
 
@@ -16,12 +17,22 @@ export const getRunConfig = async () => {
  * Configure the custom cache handler at request time
  */
 export const setRunConfig = (config: NextConfigComplete) => {
+  const cacheHandler = join(PLUGIN_DIR, 'dist/run/handlers/cache.cjs')
+  if (!existsSync(cacheHandler)) {
+    throw new Error(`Cache handler not found at ${cacheHandler}`)
+  }
+
   // set the path to the cache handler
   config.experimental = {
     ...config.experimental,
-    incrementalCacheHandlerPath: `${PLUGIN_DIR}/dist/run/handlers/cache.cjs`,
+    incrementalCacheHandlerPath: cacheHandler,
   }
 
+  // Next.js 14.1.0 moved the cache handler from experimental to stable
+  // https://github.com/vercel/next.js/pull/57953/files#diff-c49c4767e6ed8627e6e1b8f96b141ee13246153f5e9142e1da03450c8e81e96fL311
+  config.cacheHandler = cacheHandler
+  config.cacheMaxMemorySize = 0
+
   // set config
   process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config)
 }

tests/e2e/package-manager.test.ts

@@ -6,6 +6,19 @@ let ctx: Awaited<ReturnType<typeof createE2EFixture>>
 // those tests have different fixtures and can run in parallel
 test.describe.configure({ mode: 'parallel' })
 
+test.afterEach(async ({ page }, testInfo) => {
+  if (testInfo.status !== testInfo.expectedStatus) {
+    const screenshotPath = testInfo.outputPath(`failure.png`)
+    // Add it to the report to see the failure immediately
+    testInfo.attachments.push({
+      name: 'failure',
+      path: screenshotPath,
+      contentType: 'image/png',
+    })
+    await page.screenshot({ path: screenshotPath, timeout: 5000 })
+  }
+})
+
 test.describe('[Yarn] Package manager', () => {
   test.describe('simple-next-app', () => {
     test.beforeAll(async () => {