Replace server fields with typed dev state

Author: timneutkens

packages/next/errors.json

@@ -1322,5 +1322,7 @@
   "1321": "\\`partialPrefetching\\` requires \\`cacheComponents\\` to be enabled. Please update your %s accordingly.",
   "1322": "Route \"%s\" cannot use \\`export const prefetch = ...\\` without enabling \\`cacheComponents\\`.",
   "1323": "\"prefetch\" is a route segment config and can only be used when the segment is a Server Component module. Remove the \"use client\" directive from \"%s\" to use this API.",
-  "1324": "Invariant: dev virtual filesystem item was not handled by the development bundler"
+  "1324": "Invariant: dev virtual filesystem item was not handled by the development bundler",
+  "1325": "Invariant: dev server state can only be updated in dev",
+  "1326": "Invariant: no app initialized"
 }

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

@@ -248,6 +248,15 @@ export interface Options {
    * The HTTP Server that Next.js is running behind
    */
   httpServer?: HTTPServer
+  /**
+   * The router server handler used for internal requests.
+   *
+   * @internal
+   */
+  routerServerHandler?: (
+    req: IncomingMessage,
+    res: HTTPServerResponse
+  ) => Promise<void> | void
 }
 
 export type RenderOpts = PagesRenderOptsPartial & AppRenderOptsPartial
@@ -341,7 +350,7 @@ export default abstract class Server<
   protected readonly minimalMode: boolean
   protected readonly renderOpts: BaseRenderOpts
   protected readonly serverOptions: Readonly<ServerOptions>
-  protected readonly appPathRoutes?: Record<string, string[]>
+  protected appPathRoutes?: Record<string, string[]>
   protected readonly clientReferenceManifest?: DeepReadonly<ClientReferenceManifest>
   protected interceptionRoutePatterns: RegExp[]
   protected nextFontManifest?: DeepReadonly<NextFontManifest>

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

@@ -0,0 +1,13 @@
+import type { ProxyMatcher } from '../../build/analysis/get-page-static-info'
+
+export type DevServerState = {
+  actualMiddlewareFile?: string
+  actualInstrumentationHookFile?: string
+  appPathRoutes?: Record<string, string[]>
+  middleware?: {
+    page: string
+    matchers?: ProxyMatcher[]
+  }
+}
+
+export type DevServerStateUpdate = Partial<DevServerState>

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

@@ -62,10 +62,10 @@ import {
   type StartChangeSubscription,
 } from './turbopack-utils'
 import {
-  propagateServerField,
-  type ServerFields,
   type SetupOpts,
+  updateDevServerState,
 } from '../lib/router-utils/setup-dev-bundler'
+import type { DevServerState } from './dev-server-state'
 import { TurbopackManifestLoader } from '../../shared/lib/turbopack/manifest-loader'
 import { findPagePathData } from './on-demand-entry-handler'
 import type { RouteDefinition } from '../route-definitions/route-definition'
@@ -306,7 +306,7 @@ function getSourceMapFromTurbopack(
 
 export async function createHotReloaderTurbopack(
   opts: SetupOpts & { isSrcDir: boolean },
-  serverFields: ServerFields,
+  devServerState: DevServerState,
   distDir: string,
   resetFetch: () => void,
   lockfile: Lockfile | undefined,
@@ -943,14 +943,17 @@ export async function createHotReloaderTurbopack(
             ...clientsByHtmlRequestId.values(),
           ],
           clientStates,
-          serverFields,
 
           hooks: {
             handleWrittenEndpoint: (id, result, forceDeleteCache) => {
               currentWrittenEntrypoints.set(id, result)
               return clearRequireCache(id, result, { force: forceDeleteCache })
             },
-            propagateServerField: propagateServerField.bind(null, opts),
+            updateDevServerState: updateDevServerState.bind(
+              null,
+              opts,
+              devServerState
+            ),
             sendHmr,
             startBuilding,
             subscribeToChanges: subscribeToClientChanges,

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

@@ -79,6 +79,7 @@ import type { PrerenderManifest } from '../../build'
 import { getRouteRegex } from '../../shared/lib/router/utils/route-regex'
 import type { PrerenderedRoute } from '../../build/static-paths/types'
 import { HMR_MESSAGE_SENT_TO_BROWSER } from './hot-reloader-types'
+import type { DevServerStateUpdate } from './dev-server-state'
 
 // Load ReactDevOverlay only when needed
 let PagesDevOverlayBridgeImpl: PagesDevOverlayBridgeType
@@ -226,6 +227,27 @@ export default class DevServer extends Server {
     return this.serverComponentsHmrCache
   }
 
+  public override updateDevServerState(update: DevServerStateUpdate): void {
+    if ('actualMiddlewareFile' in update) {
+      this.actualMiddlewareFile = update.actualMiddlewareFile
+    }
+    if ('actualInstrumentationHookFile' in update) {
+      this.actualInstrumentationHookFile = update.actualInstrumentationHookFile
+    }
+    if ('middleware' in update) {
+      this.middleware = update.middleware
+        ? {
+            ...update.middleware,
+            match: getMiddlewareRouteMatcher(update.middleware.matchers || []),
+          }
+        : undefined
+    }
+    if ('appPathRoutes' in update) {
+      this.appPathRoutes = update.appPathRoutes
+      this.interceptionRoutePatterns = this.getinterceptionRoutePatterns()
+    }
+  }
+
   protected getBuildId(): string {
     return 'development'
   }
@@ -594,13 +616,6 @@ export default class DevServer extends Server {
   }
 
   protected async getMiddleware() {
-    // We need to populate the match
-    // field as it isn't serializable
-    if (this.middleware?.match === null) {
-      this.middleware.match = getMiddlewareRouteMatcher(
-        this.middleware.matchers || []
-      )
-    }
     return this.middleware
   }
 

packages/next/src/server/dev/turbopack-utils.ts

@@ -1,7 +1,5 @@
-import type {
-  ServerFields,
-  SetupOpts,
-} from '../lib/router-utils/setup-dev-bundler'
+import type { SetupOpts } from '../lib/router-utils/setup-dev-bundler'
+import type { DevServerStateUpdate } from './dev-server-state'
 import type {
   Issue,
   TurbopackResult,
@@ -16,7 +14,6 @@ import {
 } from './hot-reloader-types'
 import * as Log from '../../build/output/log'
 import { warnAboutEdgeRuntime } from '../../build/warn-about-edge-runtime'
-import type { PropagateToWorkersField } from '../lib/router-utils/types'
 import type { TurbopackManifestLoader } from '../../shared/lib/turbopack/manifest-loader'
 import type { AppRoute, Entrypoints, PageRoute } from '../../build/swc/types'
 import {
@@ -547,10 +544,7 @@ export function hasEntrypointForKey(
 // hooks only used by the dev server.
 type HandleEntrypointsHooks = {
   handleWrittenEndpoint: HandleWrittenEndpoint
-  propagateServerField: (
-    field: PropagateToWorkersField,
-    args: any
-  ) => Promise<void>
+  updateDevServerState: (update: DevServerStateUpdate) => Promise<void>
   sendHmr: SendHmr
   startBuilding: StartBuilding
   subscribeToChanges: StartChangeSubscription
@@ -563,7 +557,6 @@ type HandleEntrypointsDevOpts = {
   changeSubscriptions: ChangeSubscriptions
   clients: Array<ws>
   clientStates: ClientStateMap
-  serverFields: ServerFields
 
   hooks: HandleEntrypointsHooks
 }
@@ -691,17 +684,13 @@ export async function handleEntrypoints({
       entrypoints: currentEntrypoints,
     })
 
-    dev.serverFields.actualInstrumentationHookFile = '/instrumentation'
-    await dev.hooks.propagateServerField(
-      'actualInstrumentationHookFile',
-      dev.serverFields.actualInstrumentationHookFile
-    )
+    await dev.hooks.updateDevServerState({
+      actualInstrumentationHookFile: '/instrumentation',
+    })
   } else {
-    dev.serverFields.actualInstrumentationHookFile = undefined
-    await dev.hooks.propagateServerField(
-      'actualInstrumentationHookFile',
-      dev.serverFields.actualInstrumentationHookFile
-    )
+    await dev.hooks.updateDevServerState({
+      actualInstrumentationHookFile: undefined,
+    })
   }
 
   if (middleware) {
@@ -726,11 +715,12 @@ export async function handleEntrypoints({
         manifestLoader.getMiddlewareManifest(key)?.middleware['/']
 
       if (dev && middlewareConfig) {
-        dev.serverFields.middleware = {
-          match: null as any,
-          page: '/',
-          matchers: middlewareConfig.matchers,
-        }
+        await dev.hooks.updateDevServerState({
+          middleware: {
+            page: '/',
+            matchers: middlewareConfig.matchers,
+          },
+        })
       }
       finishBuilding()
     }
@@ -748,14 +738,6 @@ export async function handleEntrypoints({
             true
           )
           await processMiddleware()
-          await dev.hooks.propagateServerField(
-            'actualMiddlewareFile',
-            dev.serverFields.actualMiddlewareFile
-          )
-          await dev.hooks.propagateServerField(
-            'middleware',
-            dev.serverFields.middleware
-          )
           manifestLoader.writeManifests({
             devRewrites,
             productionRewrites: undefined,
@@ -778,18 +760,11 @@ export async function handleEntrypoints({
     manifestLoader.deleteMiddlewareManifest(
       getEntryKey('root', 'server', 'middleware')
     )
-    dev.serverFields.actualMiddlewareFile = undefined
-    dev.serverFields.middleware = undefined
+    await dev.hooks.updateDevServerState({
+      actualMiddlewareFile: undefined,
+      middleware: undefined,
+    })
   }
-
-  await dev.hooks.propagateServerField(
-    'actualMiddlewareFile',
-    dev.serverFields.actualMiddlewareFile
-  )
-  await dev.hooks.propagateServerField(
-    'middleware',
-    dev.serverFields.middleware
-  )
 }
 
 async function handleEntrypointsDevCleanup({

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

@@ -1,6 +1,10 @@
 import type { NextServer, RequestHandler, UpgradeHandler } from '../next'
 import type { DevBundlerService } from './dev-bundler-service'
-import type { PropagateToWorkersField } from './router-utils/types'
+import type {
+  DevServerState,
+  DevServerStateUpdate,
+} from '../dev/dev-server-state'
+import type { WorkerRequestHandler } from './types'
 
 import next from '../next'
 import type { Span } from '../../trace'
@@ -43,44 +47,27 @@ export function clearModuleContext(target: string) {
   return sandboxContext?.clearModuleContext(target)
 }
 
-export async function getServerField(
-  dir: string,
-  field: PropagateToWorkersField
-) {
+async function getInitialization(dir: string) {
   const initialization = await initializations[dir]
   if (!initialization) {
-    throw new Error('Invariant cant propagate server field, no app initialized')
+    throw new Error('Invariant: no app initialized')
   }
-  const { server } = initialization
-  let wrappedServer = server['server']! // NextServer.server is private
-  return wrappedServer[field as keyof typeof wrappedServer]
+  return initialization
 }
 
-export async function propagateServerField(
+export async function updateDevServerState(
   dir: string,
-  field: PropagateToWorkersField,
-  value: any
+  update: DevServerStateUpdate
 ) {
-  const initialization = await initializations[dir]
-  if (!initialization) {
-    throw new Error('Invariant cant propagate server field, no app initialized')
-  }
+  const initialization = await getInitialization(dir)
   const { server } = initialization
-  let wrappedServer = server['server']
-  const _field = field as keyof NonNullable<typeof wrappedServer>
-
-  if (wrappedServer) {
-    if (typeof wrappedServer[_field] === 'function') {
-      // @ts-expect-error
-      await wrappedServer[_field].apply(
-        wrappedServer,
-        Array.isArray(value) ? value : []
-      )
-    } else {
-      // @ts-expect-error
-      wrappedServer[_field] = value
-    }
-  }
+  await server.updateDevServerState(update)
+}
+
+export async function reloadEnv(dir: string) {
+  const initialization = await getInitialization(dir)
+  const { server } = initialization
+  await server.reloadEnv()
 }
 
 async function initializeImpl(opts: {
@@ -90,7 +77,8 @@ async function initializeImpl(opts: {
   minimalMode?: boolean
   hostname?: string
   keepAliveTimeout?: number
-  serverFields?: any
+  devServerState?: DevServerState
+  routerServerHandler?: WorkerRequestHandler
   server?: any
   experimentalTestProxy: boolean
   experimentalHttpsServer: boolean
@@ -112,8 +100,9 @@ async function initializeImpl(opts: {
   let requestHandler: RequestHandler
   let upgradeHandler: UpgradeHandler
 
+  const { devServerState, ...serverOptions } = opts
   const server = next({
-    ...opts,
+    ...serverOptions,
     hostname: opts.hostname || 'localhost',
     customServer: false,
     httpServer: opts.server,
@@ -169,7 +158,10 @@ async function initializeImpl(opts: {
     upgradeHandler = server.getUpgradeHandler()
   }
 
-  await server.prepare(opts.serverFields)
+  if (devServerState) {
+    await server.updateDevServerState(devServerState)
+  }
+  await server.prepare()
 
   return {
     requestHandler,