Merge app renderer process

packages/next-env/index.ts

@@ -26,8 +26,12 @@ type Log = {
 
 function replaceProcessEnv(sourceEnv: Env) {
   Object.keys(process.env).forEach((key) => {
-    if (sourceEnv[key] === undefined || sourceEnv[key] === '') {
-      delete process.env[key]
+    // Allow mutating internal Next.js env variables after the server has initiated.
+    // This is necessary for dynamic things like the IPC server port.
+    if (!key.startsWith('__NEXT_PRIVATE')) {
+      if (sourceEnv[key] === undefined || sourceEnv[key] === '') {
+        delete process.env[key]
+      }
     }
   })
 

packages/next/src/build/utils.ts

@@ -1935,14 +1935,12 @@ export async function copyTracedFiles(
     serverOutputPath,
     `${
       moduleType
-        ? `import http from 'http'
-import path from 'path'
+        ? `import path from 'path'
 import { fileURLToPath } from 'url'
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 import { startServer } from 'next/dist/server/lib/start-server.js'
 `
         : `
-const http = require('http')
 const path = require('path')
 const { startServer } = require('next/dist/server/lib/start-server')`
     }
@@ -1961,13 +1959,17 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
 
 const currentPort = parseInt(process.env.PORT, 10) || 3000
 const hostname = process.env.HOSTNAME || 'localhost'
-let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
+
+let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10)
 const nextConfig = ${JSON.stringify({
       ...serverConfig,
       distDir: `./${path.relative(dir, distDir)}`,
     })}
 
 process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
+process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = nextConfig.experimental && nextConfig.experimental.serverActions
+  ? 'experimental'
+  : 'next'
 
 if (
   Number.isNaN(keepAliveTimeout) ||

packages/next/src/cli/next-dev.ts

@@ -121,7 +121,7 @@ function watchConfigFiles(
 type StartServerWorker = Worker &
   Pick<typeof import('../server/lib/start-server'), 'startServer'>
 
-async function createRouterWorker(): Promise<{
+async function createRouterWorker(fullConfig: NextConfigComplete): Promise<{
   worker: StartServerWorker
   cleanup: () => Promise<void>
 }> {
@@ -143,6 +143,9 @@ async function createRouterWorker(): Promise<{
           : {}),
         WATCHPACK_WATCHER_LIMIT: '20',
         EXPERIMENTAL_TURBOPACK: process.env.EXPERIMENTAL_TURBOPACK,
+        __NEXT_PRIVATE_PREBUNDLED_REACT: !!fullConfig.experimental.serverActions
+          ? 'experimental'
+          : 'next',
       },
     },
     exposedMethods: ['startServer'],
@@ -394,7 +397,7 @@ const nextDev: CliCommand = async (argv) => {
   } else {
     const runDevServer = async (reboot: boolean) => {
       try {
-        const workerInit = await createRouterWorker()
+        const workerInit = await createRouterWorker(config)
         if (!!args['--experimental-https']) {
           Log.warn(
             'Self-signed certificates are currently an experimental feature, use at your own risk.'

packages/next/src/server/base-server.ts

@@ -1040,7 +1040,6 @@ export default abstract class Server<ServerOptions extends Options = Options> {
       const useInvokePath =
         !useMatchedPathHeader &&
         process.env.NEXT_RUNTIME !== 'edge' &&
-        process.env.__NEXT_PRIVATE_RENDER_WORKER &&
         invokePath
 
       if (useInvokePath) {
@@ -1131,7 +1130,6 @@ export default abstract class Server<ServerOptions extends Options = Options> {
 
       if (
         process.env.NEXT_RUNTIME !== 'edge' &&
-        process.env.__NEXT_PRIVATE_RENDER_WORKER &&
         req.headers['x-middleware-invoke']
       ) {
         const nextDataResult = await this.normalizeNextData(req, res, parsedUrl)

packages/next/src/server/lib/render-server.ts

@@ -80,8 +80,10 @@ export async function initialize(opts: {
     return result
   }
 
-  const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
-  process.title = 'next-render-worker-' + type
+  const type = process.env.__NEXT_PRIVATE_RENDER_WORKER
+  if (type) {
+    process.title = 'next-render-worker-' + type
+  }
 
   let requestHandler: RequestHandler
   let upgradeHandler: any

packages/next/src/server/lib/router-server.ts

@@ -38,15 +38,14 @@ import { signalFromNodeResponse } from '../web/spec-extension/adapters/next-requ
 
 const debug = setupDebug('next:router-server:main')
 
-export type RenderWorker = InstanceType<
-  typeof import('next/dist/compiled/jest-worker').Worker
-> & {
-  initialize: typeof import('./render-server').initialize
-  deleteCache: typeof import('./render-server').deleteCache
-  deleteAppClientCache: typeof import('./render-server').deleteAppClientCache
-  clearModuleContext: typeof import('./render-server').clearModuleContext
-  propagateServerField: typeof import('./render-server').propagateServerField
-}
+export type RenderWorker = Pick<
+  typeof import('./render-server'),
+  | 'initialize'
+  | 'deleteCache'
+  | 'clearModuleContext'
+  | 'deleteAppClientCache'
+  | 'propagateServerField'
+>
 
 export interface RenderWorkers {
   app?: Awaited<ReturnType<typeof createWorker>>
@@ -185,16 +184,19 @@ export async function initialize(opts: {
     },
   } as any)
 
-  const { initialEnv } = require('@next/env') as typeof import('@next/env')
+  if (!!config.experimental.appDir) {
+    process.env.__NEXT_PRIVATE_ROUTER_IPC_PORT = ipcPort + ''
+    process.env.__NEXT_PRIVATE_ROUTER_IPC_KEY = ipcValidationKey
+    process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = config.experimental
+      .serverActions
+      ? 'experimental'
+      : 'next'
 
-  renderWorkers.app = await createWorker(
-    ipcPort,
-    ipcValidationKey,
-    opts.isNodeDebugging,
-    'app',
-    config,
-    initialEnv
-  )
+    renderWorkers.app =
+      require('./render-server') as typeof import('./render-server')
+  }
+
+  const { initialEnv } = require('@next/env') as typeof import('@next/env')
   renderWorkers.pages = await createWorker(
     ipcPort,
     ipcValidationKey,
@@ -272,10 +274,16 @@ export async function initialize(opts: {
     }
   }
 
+  const logError = async (
+    type: 'uncaughtException' | 'unhandledRejection',
+    err: Error | undefined
+  ) => {
+    await devInstance?.logErrorWithOriginalStack(err, type)
+  }
+
   const cleanup = () => {
     debug('router-server process cleanup')
     for (const curWorker of [
-      ...((renderWorkers.app as any)?._workerPool?._workers || []),
       ...((renderWorkers.pages as any)?._workerPool?._workers || []),
     ] as {
       _child?: import('child_process').ChildProcess
@@ -290,8 +298,8 @@ export async function initialize(opts: {
   process.on('exit', cleanup)
   process.on('SIGINT', cleanup)
   process.on('SIGTERM', cleanup)
-  process.on('uncaughtException', cleanup)
-  process.on('unhandledRejection', cleanup)
+  process.on('uncaughtException', logError.bind(null, 'uncaughtException'))
+  process.on('unhandledRejection', logError.bind(null, 'unhandledRejection'))
 
   const resolveRoutes = getResolveRoutes(
     fsChecker,

packages/next/src/server/lib/router-utils/resolve-routes.ts

@@ -2,10 +2,10 @@ import type { TLSSocket } from 'tls'
 import type { FsOutput } from './filesystem'
 import type { IncomingMessage } from 'http'
 import type { NextConfigComplete } from '../../config-shared'
+import type { RenderWorker, initialize } from '../router-server'
 
 import url from 'url'
 import { Redirect } from '../../../../types'
-import { RenderWorker } from '../router-server'
 import setupDebug from 'next/dist/compiled/debug'
 import { getCloneableBody } from '../../body-streams'
 import { filterReqHeaders, ipcForbiddenHeaders } from '../server-ipc/utils'
@@ -46,7 +46,7 @@ export function getResolveRoutes(
     ReturnType<typeof import('./filesystem').setupFsCheck>
   >,
   config: NextConfigComplete,
-  opts: Parameters<typeof import('../router-server').initialize>[0],
+  opts: Parameters<typeof initialize>[0],
   renderWorkers: {
     app?: RenderWorker
     pages?: RenderWorker

packages/next/src/server/lib/server-ipc/index.ts

@@ -1,13 +1,13 @@
 import type NextServer from '../../next-server'
 import type { NextConfigComplete } from '../../config-shared'
+import type { RenderWorker } from '../router-server'
 
 import { getNodeOptionsWithoutInspect } from '../utils'
 import { errorToJSON } from '../../render'
 import crypto from 'crypto'
 import isError from '../../../lib/is-error'
 import { genRenderExecArgv } from '../worker-utils'
 import { deserializeErr } from './request-utils'
-import { RenderWorker } from '../router-server'
 import type { Env } from '@next/env'
 
 // we can't use process.send as jest-worker relies on
@@ -115,13 +115,8 @@ export const createWorker = async (
         __NEXT_PRIVATE_STANDALONE_CONFIG:
           process.env.__NEXT_PRIVATE_STANDALONE_CONFIG,
         NODE_ENV: process.env.NODE_ENV,
-        ...(type === 'app'
-          ? {
-              __NEXT_PRIVATE_PREBUNDLED_REACT: useServerActions
-                ? 'experimental'
-                : 'next',
-            }
-          : {}),
+        __NEXT_PRIVATE_PREBUNDLED_REACT:
+          type === 'app' ? (useServerActions ? 'experimental' : 'next') : '',
         ...(process.env.NEXT_CPU_PROF
           ? { __NEXT_PRIVATE_CPU_PROFILE: `CPU.${type}-renderer` }
           : {}),
@@ -135,7 +130,8 @@ export const createWorker = async (
       'clearModuleContext',
       'propagateServerField',
     ],
-  }) as any as RenderWorker
+  }) as any as RenderWorker &
+    InstanceType<typeof import('next/dist/compiled/jest-worker').Worker>
 
   worker.getStderr().pipe(process.stderr)
   worker.getStdout().pipe(process.stdout)

packages/next/src/server/lib/start-server.ts

@@ -1,4 +1,5 @@
 import '../node-polyfill-fetch'
+import '../require-hook'
 
 import type { IncomingMessage, ServerResponse } from 'http'
 
@@ -220,11 +221,15 @@ export async function startServer({
           server.close()
           process.exit(0)
         }
+        const exception = (err: Error) => {
+          // This is the render worker, we keep the process alive
+          console.error(err)
+        }
         process.on('exit', cleanup)
         process.on('SIGINT', cleanup)
         process.on('SIGTERM', cleanup)
-        process.on('uncaughtException', cleanup)
-        process.on('unhandledRejection', cleanup)
+        process.on('uncaughtException', exception)
+        process.on('unhandledRejection', exception)
 
         const initResult = await getRequestHandlers({
           dir,

packages/next/src/server/next-server.ts

@@ -491,15 +491,6 @@ export default class NextNodeServer extends BaseServer {
     )
   }
 
-  private streamResponseChunk(res: ServerResponse, chunk: any) {
-    res.write(chunk)
-    // When streaming is enabled, we need to explicitly
-    // flush the response to avoid it being buffered.
-    if ('flush' in res) {
-      ;(res as any).flush()
-    }
-  }
-
   protected async imageOptimizer(
     req: NodeNextRequest,
     res: NodeNextResponse,
@@ -1033,7 +1024,7 @@ export default class NextNodeServer extends BaseServer {
         return {
           finished: true,
         }
-      } catch (_) {}
+      } catch {}
 
       throw err
     }

test/development/basic/node-builtins.test.ts

@@ -138,7 +138,6 @@ createNextDescribe(
       expect(parsedData.https).toBe(true)
       expect(parsedData.os).toBe('\n')
       expect(parsedData.path).toBe('/hello/world/test.txt')
-      expect(parsedData.process).toInclude('next-render-worker-app')
       expect(parsedData.querystring).toBe('a=b')
       expect(parsedData.stringDecoder).toBe(true)
       expect(parsedData.sys).toBe(true)
@@ -164,7 +163,6 @@ createNextDescribe(
       expect(parsedData.https).toBe(true)
       expect(parsedData.os).toBe('\n')
       expect(parsedData.path).toBe('/hello/world/test.txt')
-      expect(parsedData.process).toInclude('next-render-worker-app')
       expect(parsedData.querystring).toBe('a=b')
       expect(parsedData.stringDecoder).toBe(true)
       expect(parsedData.sys).toBe(true)

test/integration/disable-js/test/index.test.js

@@ -3,37 +3,31 @@
 import { join } from 'path'
 import cheerio from 'cheerio'
 import {
-  nextServer,
   nextBuild,
-  startApp,
-  stopApp,
   renderViaHTTP,
   findPort,
   launchApp,
   killApp,
+  nextStart,
 } from 'next-test-utils'
 
 const appDir = join(__dirname, '../')
 let appPort
-let server
 let app
 
 const context = {}
 
 describe('disabled runtime JS', () => {
   describe('production mode', () => {
     beforeAll(async () => {
+      appPort = await findPort()
+
       await nextBuild(appDir)
-      app = nextServer({
-        dir: join(__dirname, '../'),
-        dev: false,
-        quiet: true,
-      })
+      app = await nextStart(appDir, appPort)
 
-      server = await startApp(app)
-      context.appPort = appPort = server.address().port
+      context.appPort = appPort
     })
-    afterAll(() => stopApp(server))
+    afterAll(() => killApp(app))
 
     it('should render the page', async () => {
       const html = await renderViaHTTP(appPort, '/')

test/integration/future/test/index.test.js

@@ -4,30 +4,24 @@ import webdriver from 'next-webdriver'
 import { join } from 'path'
 import {
   nextBuild,
-  nextServer,
-  startApp,
-  stopApp,
+  nextStart,
+  killApp,
+  findPort,
   renderViaHTTP,
 } from 'next-test-utils'
 
 let appDir = join(__dirname, '../')
-let server
 let appPort
+let app
 
 describe('excludeDefaultMomentLocales', () => {
   beforeAll(async () => {
+    appPort = await findPort()
     await nextBuild(appDir)
-    const app = nextServer({
-      dir: appDir,
-      dev: false,
-      quiet: true,
-    })
-    server = await startApp(app)
-    appPort = server.address().port
-    // wait for it to start up:
+    app = await nextStart(appDir, appPort)
     await renderViaHTTP(appPort, '/')
   })
-  afterAll(() => stopApp(server))
+  afterAll(() => killApp(app))
 
   it('should load momentjs', async () => {
     const browser = await webdriver(appPort, '/')