Development Server

Copyexport interface Options extends ServerOptions {
  // Override type to make the full config available instead of only NextConfigRuntime
  conf: NextConfigComplete
  /**
   * Tells of Next.js is running from the `next dev` command
   */
  isNextDevCommand?: boolean
 
  /**
   * Interface to the development bundler.
   */
  bundlerService: DevBundlerService
 
  /**
   * Trace span for server startup.
   */
  startServerSpan: Span
}
 
export default class DevServer extends Server {
  // Override type to make the full config available instead of only NextConfigRuntime
  protected readonly nextConfig: NextConfigComplete
 
  /**
   * The promise that resolves when the server is ready. When this is unset
   * the server is ready.
   */
  private ready? = createPromiseWithResolvers<void>()
  protected sortedRoutes?: string[]
  private pagesDir?: string
  private appDir?: string
  private actualMiddlewareFile?: string
  private actualInstrumentationHookFile?: string
  private middleware?: MiddlewareRoutingItem
  private readonly bundlerService: DevBundlerService
  private staticPathsCache: LRUCache<
    UnwrapPromise<ReturnType<DevServer['getStaticPaths']>>
  >
  private startServerSpan: Span
  private readonly serverComponentsHmrCache:
    | ServerComponentsHmrCache
    | undefined

Copyprivate async createServer(
  options: ServerOptions | DevServerOptions
): Promise<NextNodeServer> {
  let ServerImplementation: typeof NextNodeServer
  if (options.dev) {
    ServerImplementation = (
      require('./dev/next-dev-server') as typeof import('./dev/next-dev-server')
    ).default as typeof import('./dev/next-dev-server').default
  } else {
    ServerImplementation = await getServerImpl()
  }
  const server = new ServerImplementation(options)
 
  return server
}

Copyexport class DevBundlerService {
  public appIsrManifestInner: InstanceType<typeof LRUCache<boolean>>
  public setCacheStatus: NextJsHotReloaderInterface['setCacheStatus']
  public setReactDebugChannel: NextJsHotReloaderInterface['setReactDebugChannel']
  public sendErrorsToBrowser: NextJsHotReloaderInterface['sendErrorsToBrowser']
  private unsubscribeRequestInsights?: () => void
 
  constructor(
    private readonly bundler: DevBundler,
    private readonly handler: WorkerRequestHandler,
    requestInsightsEnabled: boolean
  ) {
    this.appIsrManifestInner = new LRUCache(
      8_000,
 
      function length() {
        return 16
      }
    )
 
    const { hotReloader } = bundler
 
    this.setCacheStatus = hotReloader.setCacheStatus.bind(hotReloader)
    this.setReactDebugChannel =
      hotReloader.setReactDebugChannel.bind(hotReloader)
    this.sendErrorsToBrowser = hotReloader.sendErrorsToBrowser.bind(hotReloader)
 
    if (requestInsightsEnabled) {
      this.unsubscribeRequestInsights = subscribeRequestInsights((insight) => {
        hotReloader.send({
          type: HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_INSIGHTS_UPDATE,
          insight,
        })
      })
    }
  }

Copyexport type SetupOpts = {
  renderServer: LazyRenderServerInstance
  dir: string
  turbo?: boolean
  appDir?: string
  pagesDir?: string
  telemetry: Telemetry
  isCustomServer?: boolean
  fsChecker: UnwrapPromise<
    ReturnType<typeof import('./filesystem').setupFsCheck>
  >
  nextConfig: NextConfigComplete
  port: number
  onDevServerCleanup: ((listener: () => Promise<void>) => void) | undefined
  resetFetch: () => void
  serverFastRefresh?: boolean
  hasVulnerabilityInsight: Promise<boolean>
}

Copypublic ensurePage: typeof this.bundler.hotReloader.ensurePage = async (
  definition
) => {
  // TODO: remove after ensure is pulled out of server
  return await getTracer().trace(
    DevBundlerServiceSpan.ensurePage,
    { spanName: 'compile route' },
    () => this.bundler.hotReloader.ensurePage(definition)
  )
}

Copyexport function getEntryKey(
  compilerType: CompilerNameValues,
  pageBundleType: PAGE_TYPES,
  page: string
) {
  // TODO: handle the /children slot better
  // this is a quick hack to handle when children is provided as children/page instead of /page
  const pageKey = page.replace(/(@[^/]+)\/children/g, '$1')
  return `${compilerType}@${pageBundleType}@${pageKey}`
}

Copy// matches pages/:page*.js
const SERVER_ROUTE_NAME_REGEX = /^pages[/\\](.*)$/
 
// matches static/pages/:page*.js
const BROWSER_ROUTE_NAME_REGEX = /^static[/\\]pages[/\\](.*)$/
 
export default function getRouteFromEntrypoint(
  entryFile: string,
  app?: boolean
): string | null {
  let pagePath = matchBundle(SERVER_ROUTE_NAME_REGEX, entryFile)
 
  if (pagePath) {
    return pagePath
  }
 
  if (app) {
    pagePath = getAppRouteFromEntrypoint(entryFile)
    if (pagePath) return pagePath
  }
 
  // Potentially the passed item is a browser bundle so we try to match that also
  return matchBundle(BROWSER_ROUTE_NAME_REGEX, entryFile)

Copytype EnsurePageOptions = {
  page: string
  appPaths?: ReadonlyArray<string> | null
  definition?: RouteDefinition
  isApp?: boolean
  url?: string
}
 
// Make sure that we won't have multiple invalidations ongoing concurrently.
const batcher = Batcher.create<EnsurePageOptions, void, string>({
  // The cache key here is composed of the elements that affect the
  // compilation, namely, the page, whether it's client only, and whether
  // it's an app page. This ensures that we don't have multiple compilations
  // for the same page happening concurrently.
  //
  // We don't include the whole match because it contains match specific
  // parameters (like route params) that would just bust this cache. Any
  // details that would possibly bust the cache should be listed here.
  cacheKeyFn: (options) => JSON.stringify(options),
  // Schedule the invocation of the ensurePageImpl function on the next tick.
  schedulerFn: scheduleOnNextTick,
})
 
return {
  async ensurePage({
    page,
    appPaths = null,
    definition,
    isApp,
    url,
  }: EnsurePageOptions) {
    // If the route is actually an app page route, then we should have access
    // to the app route definition, and therefore, the appPaths from it.
    if (!appPaths && definition && isAppPageRouteDefinition(definition)) {
      appPaths = definition.appPaths
    }
 
    // Wrap the invocation of the ensurePageImpl function in the pending
    // wrapper, which will ensure that we don't have multiple compilations
    // for the same page happening concurrently.
    return batcher.batch({ page, appPaths, definition, isApp }, async () => {
      await ensurePageImpl({
        page,
        appPaths,
        definition,
        isApp,
        url,
      })
    })
  },

Copyexport function normalizeAppPath(route: string) {
  return ensureLeadingSlash(
    route.split('/').reduce((pathname, segment, index, segments) => {
      if (!segment) return pathname
      if (isGroupSegment(segment)) return pathname
      if (segment[0] === '@') return pathname
      if ((segment === 'page' || segment === 'route') && index === segments.length - 1) {
        return pathname
      }
      return `${pathname}/${segment}`
    }, '')
  )
}

Copyexport default function getRouteFromAssetPath(
  assetPath: string,
  ext: string = ''
): string {
  assetPath = assetPath.replace(/\\/g, '/')
  assetPath =
    ext && assetPath.endsWith(ext) ? assetPath.slice(0, -ext.length) : assetPath
  if (assetPath.startsWith('/index/') && !isDynamicRoute(assetPath)) {
    assetPath = assetPath.slice(6)
  } else if (assetPath === '/index') {
    assetPath = '/'
  }
  return assetPath

Copy// Identify /.*[param].*/ in route string
const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/
 
// Identify /[param]/ in route string
const TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/
 
/**
 * Check if a route is dynamic.
 *
 * @param route - The route to check.
 * @param strict - Whether to use strict mode which prohibits segments with prefixes/suffixes (default: true).
 * @returns Whether the route is dynamic.
 */
export function isDynamicRoute(route: string, strict: boolean = true): boolean {
  if (isInterceptionRouteAppPath(route)) {
    route = extractInterceptionRouteInformation(route).interceptedRoute
  }
 
  if (strict) {
    return TEST_STRICT_ROUTE.test(route)
  }
 
  return TEST_ROUTE.test(route)

Copyexport const INTERCEPTION_ROUTE_MARKERS = [
  '(..)(..)',
  '(.)',
  '(..)',
  '(...)',
] as const

Copy  const span = trace('handle-request', undefined, { url: req.url })
  const result = await span.traceAsyncFn(async () => {
    await this.ready?.promise
    addRequestMeta(req, 'PagesErrorDebug', this.renderOpts.ErrorDebug)
    return await super.handleRequest(req, res, parsedUrl)
  })
  const memoryUsage = process.memoryUsage()
  span
    .traceChild('memory-usage', {
      url: req.url,
      'memory.rss': String(memoryUsage.rss),
      'memory.heapUsed': String(memoryUsage.heapUsed),
      'memory.heapTotal': String(memoryUsage.heapTotal),
    })
    .stop()
  return result
}

Copyasync run(
  req: NodeNextRequest,
  res: NodeNextResponse,
  parsedUrl: UrlWithParsedQuery
): Promise<void> {
  await this.ready?.promise
 
  const { basePath } = this.nextConfig
  let originalPathname: string | null = null
 
  // TODO: see if we can remove this in the future
  if (basePath && pathHasPrefix(parsedUrl.pathname || '/', basePath)) {
    // strip basePath before handling dev bundles
    // If replace ends up replacing the full url it'll be `undefined`, meaning we have to default it to `/`
    originalPathname = parsedUrl.pathname
    parsedUrl.pathname = removePathPrefix(parsedUrl.pathname || '/', basePath)
  }
 
  const { pathname } = parsedUrl
 
  if (pathname!.startsWith('/_next')) {
    if (fs.existsSync(pathJoin(this.publicDir, '_next'))) {
      throw new Error(PUBLIC_DIR_MIDDLEWARE_CONFLICT)
    }
  }
 
  if (originalPathname) {
    // restore the path before continuing so that custom-routes can accurately determine
    // if they should match against the basePath or not
    parsedUrl.pathname = originalPathname
  }
  try {
    return await super.run(req, res, parsedUrl)
  } catch (error) {
    const err = getProperError(error)
    formatServerError(err)
    this.logErrorWithOriginalStack(err)
    if (!res.sent) {
      res.statusCode = 500
      try {
        return await this.renderError(err, req, res, pathname!, {
          __NEXT_PAGE: (isError(err) && err.page) || pathname || '',
        })
      } catch (internalErr) {
        console.error(internalErr)
        res.body('Internal Server Error').send()
      }
    }
  }
}

Copyexport function ignoreLoggingIncomingRequests(
  request: NodeNextRequest,
  loggingConfig: LoggingConfig | undefined
): boolean {
  // If it's boolean use the boolean value
  if (typeof loggingConfig?.incomingRequests === 'boolean') {
    return !loggingConfig.incomingRequests
  }
 
  // Any of the value on the chain is falsy, will not ignore the request.
  const ignore = loggingConfig?.incomingRequests?.ignore
 
  // If ignore is not set, don't ignore anything
  if (!ignore) {
    return false
  }
 
  // If array of RegExp, ignore if any pattern matches
  return ignore.some((pattern) => pattern.test(request.url))
}

Copyconst statusCodeColor =
  statusCode < 200
    ? white
    : statusCode < 300
      ? green
      : statusCode < 400
        ? blue
        : statusCode < 500
          ? yellow
          : red

Copyfunction formatCacheStatus(cacheStatus: FetchMetric['cacheStatus']): string {
  switch (cacheStatus) {
    case 'hmr':
      return green('(HMR cache)')
    case 'hit':
      return green('(cache hit)')
    case 'miss':
    case 'skip':
      return yellow(`(cache ${cacheStatus})`)
    default:
      return cacheStatus satisfies never
  }

Copypublic async getCompilationError(page: string) {
  const errors = await this.bundler.hotReloader.getCompilationErrors(page)
  if (!errors) return
 
  // Return the very first error we found.
  return errors[0]
}

Copytry {
  const error = getHmrServerError()
 
  // New error occurred: buffered error is flushed and new error occurred
  if (!bufferedHmrServerError && error) {
    hotReloader.send({
      type: HMR_MESSAGE_SENT_TO_BROWSER.SERVER_ERROR,
      errorJSON: stringifyError(error),
    })
    bufferedHmrServerError = null
  }
 

Copypublic async getFallbackErrorComponents(url?: string) {
  await this.bundler.hotReloader.buildFallbackError()
  // Build the error page to ensure the fallback is built too.
  // TODO: See if this can be moved into hotReloader or removed.
  await this.bundler.hotReloader.ensurePage({
    page: '/_error',
    clientOnly: false,
    definition: undefined,
    url,
  })
}

Copyprotected logErrorWithOriginalStack(
  err?: unknown,
  type?: 'unhandledRejection' | 'uncaughtException' | 'warning' | 'app-dir'
): void {
  this.bundlerService.logErrorWithOriginalStack(err, type)
}