Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

26.9 kB

import type { IncomingMessage, ServerResponse } from 'node:http'
import type { ParsedUrlQuery } from 'node:querystring'
import { RouteKind } from '../../route-kind'
import { BaseServerSpan } from '../../lib/trace/constants'
import { getTracer, SpanKind, type Span } from '../../lib/trace/tracer'
import { formatUrl } from '../../../shared/lib/router/utils/format-url'
import { addRequestMeta, getRequestMeta } from '../../request-meta'
import { interopDefault } from '../../app-render/interop-default'
import { getRevalidateReason } from '../../instrumentation/utils'
import { normalizeDataPath } from '../../../shared/lib/page-path/normalize-data-path'
import {
  CachedRouteKind,
  type CachedPageValue,
  type CachedRedirectValue,
  type ResponseCacheEntry,
  type ResponseGenerator,
} from '../../response-cache'

import {
  getCacheControlHeader,
  type CacheControl,
} from '../../lib/cache-control'
import { normalizeRepeatedSlashes } from '../../../shared/lib/utils'
import { getRedirectStatus } from '../../../lib/redirect-status'
import {
  CACHE_ONE_YEAR,
  HTML_CONTENT_TYPE_HEADER,
  JSON_CONTENT_TYPE_HEADER,
} from '../../../lib/constants'
import path from 'path'
import { sendRenderResult } from '../../send-payload'
import RenderResult from '../../render-result'
import { toResponseCacheEntry } from '../../response-cache/utils'
import { NoFallbackError } from '../../../shared/lib/no-fallback-error.external'
import { RedirectStatusCode } from '../../../client/components/redirect-status-code'
import { isBot } from '../../../shared/lib/router/utils/is-bot'
import { addPathPrefix } from '../../../shared/lib/router/utils/add-path-prefix'
import { removeTrailingSlash } from '../../../shared/lib/router/utils/remove-trailing-slash'
import type { PagesRouteModule } from './module.compiled'
import type {
  GetServerSideProps,
  GetStaticPaths,
  GetStaticProps,
} from '../../../types'

export const getHandler = ({
  srcPage: originalSrcPage,
  config,
  userland,
  routeModule,
  isFallbackError,
  getStaticPaths,
  getStaticProps,
  getServerSideProps,
}: {
  srcPage: string
  config: Record<string, any> | undefined
  userland: any
  isFallbackError?: boolean
  routeModule: PagesRouteModule
  getStaticProps?: GetStaticProps
  getStaticPaths?: GetStaticPaths
  getServerSideProps?: GetServerSideProps
}) => {
  return async function handler(
    req: IncomingMessage,
    res: ServerResponse,
    ctx: {
      waitUntil: (prom: Promise<void>) => void
    }
  ): Promise<void> {
    let srcPage = originalSrcPage
    // turbopack doesn't normalize `/index` in the page name
    // so we need to to process dynamic routes properly
    // TODO: fix turbopack providing differing value from webpack
    if (process.env.TURBOPACK) {
      srcPage = srcPage.replace(/\/index$/, '') || '/'
    } else if (srcPage === '/index') {
      // we always normalize /index specifically
      srcPage = '/'
    }
    const multiZoneDraftMode = process.env
      .__NEXT_MULTI_ZONE_DRAFT_MODE as any as boolean

    const prepareResult = await routeModule.prepare(req, res, {
      srcPage,
      multiZoneDraftMode,
    })

    if (!prepareResult) {
      res.statusCode = 400
      res.end('Bad Request')
      ctx.waitUntil?.(Promise.resolve())
      return
    }

    const {
      buildId,
      query,
      params,
      parsedUrl,
      originalQuery,
      originalPathname,
      buildManifest,
      fallbackBuildManifest,
      nextFontManifest,
      serverFilesManifest,
      reactLoadableManifest,
      prerenderManifest,
      isDraftMode,
      isOnDemandRevalidate,
      revalidateOnlyGenerated,
      locale,
      locales,
      defaultLocale,
      routerServerContext,
      nextConfig,
      resolvedPathname,
    } = prepareResult

    const isExperimentalCompile =
      serverFilesManifest?.config?.experimental?.isExperimentalCompile

    const hasServerProps = Boolean(getServerSideProps)
    const hasStaticProps = Boolean(getStaticProps)
    const hasStaticPaths = Boolean(getStaticPaths)
    const hasGetInitialProps = Boolean(
      (userland.default || userland).getInitialProps
    )
    const isAmp = query.amp && config?.amp
    let cacheKey: null | string = null
    let isIsrFallback = false
    let isNextDataRequest =
      prepareResult.isNextDataRequest && (hasStaticProps || hasServerProps)

    const is404Page = srcPage === '/404'
    const is500Page = srcPage === '/500'
    const isErrorPage = srcPage === '/_error'

    if (!routeModule.isDev && !isDraftMode && hasStaticProps) {
      cacheKey = `${locale ? `/${locale}` : ''}${
        (srcPage === '/' || resolvedPathname === '/') && locale
          ? ''
          : resolvedPathname
      }${isAmp ? '.amp' : ''}`

      if (is404Page || is500Page || isErrorPage) {
        cacheKey = `${locale ? `/${locale}` : ''}${srcPage}${isAmp ? '.amp' : ''}`
      }

      // ensure /index and / is normalized to one key
      cacheKey = cacheKey === '/index' ? '/' : cacheKey
    }

    if (hasStaticPaths && !isDraftMode) {
      const decodedPathname = removeTrailingSlash(
        locale
          ? addPathPrefix(resolvedPathname, `/${locale}`)
          : resolvedPathname
      )
      const isPrerendered =
        Boolean(prerenderManifest.routes[decodedPathname]) ||
        prerenderManifest.notFoundRoutes.includes(decodedPathname)

      const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage]

      if (prerenderInfo) {
        if (prerenderInfo.fallback === false && !isPrerendered) {
          throw new NoFallbackError()
        }

        if (
          typeof prerenderInfo.fallback === 'string' &&
          !isPrerendered &&
          !isNextDataRequest
        ) {
          isIsrFallback = true
        }
      }
    }

    // When serving a bot request, we want to serve a blocking render and not
    // the prerendered page. This ensures that the correct content is served
    // to the bot in the head.
    if (
      (isIsrFallback && isBot(req.headers['user-agent'] || '')) ||
      getRequestMeta(req, 'minimalMode')
    ) {
      isIsrFallback = false
    }

    const tracer = getTracer()
    const activeSpan = tracer.getActiveScopeSpan()

    try {
      const method = req.method || 'GET'

      const resolvedUrl = formatUrl({
        pathname: nextConfig.trailingSlash
          ? parsedUrl.pathname
          : removeTrailingSlash(parsedUrl.pathname || '/'),
        // make sure to only add query values from original URL
        query: hasStaticProps ? {} : originalQuery,
      })

      const publicRuntimeConfig: Record<string, string> =
        routerServerContext?.publicRuntimeConfig ||
        nextConfig.publicRuntimeConfig

      const handleResponse = async (span?: Span) => {
        const responseGenerator: ResponseGenerator = async ({
          previousCacheEntry,
        }) => {
          const doRender = async () => {
            try {
              return await routeModule
                .render(req, res, {
                  query:
                    hasStaticProps && !isExperimentalCompile
                      ? ({
                          ...params,
                          ...(isAmp
                            ? {
                                amp: query.amp,
                              }
                            : {}),
                        } as ParsedUrlQuery)
                      : {
                          ...query,
                          ...params,
                        },
                  params,
                  page: srcPage,
                  renderContext: {
                    isDraftMode,
                    isFallback: isIsrFallback,
                    developmentNotFoundSourcePage: getRequestMeta(
                      req,
                      'developmentNotFoundSourcePage'
                    ),
                  },
                  sharedContext: {
                    buildId,
                    customServer:
                      Boolean(routerServerContext?.isCustomServer) || undefined,
                    deploymentId: process.env.NEXT_DEPLOYMENT_ID,
                  },
                  renderOpts: {
                    params,
                    routeModule,
                    page: srcPage,
                    pageConfig: config || {},
                    Component: interopDefault(userland),
                    ComponentMod: userland,
                    getStaticProps,
                    getStaticPaths,
                    getServerSideProps,
                    supportsDynamicResponse: !hasStaticProps,
                    buildManifest: isFallbackError
                      ? fallbackBuildManifest
                      : buildManifest,
                    nextFontManifest,
                    reactLoadableManifest,

                    assetPrefix: nextConfig.assetPrefix,
                    previewProps: prerenderManifest.preview,
                    images: nextConfig.images as any,
                    nextConfigOutput: nextConfig.output,
                    optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
                    nextScriptWorkers: Boolean(
                      nextConfig.experimental.nextScriptWorkers
                    ),
                    domainLocales: nextConfig.i18n?.domains,
                    crossOrigin: nextConfig.crossOrigin,

                    multiZoneDraftMode,
                    basePath: nextConfig.basePath,
                    canonicalBase: nextConfig.amp.canonicalBase || '',
                    ampOptimizerConfig: nextConfig.experimental.amp?.optimizer,
                    disableOptimizedLoading:
                      nextConfig.experimental.disableOptimizedLoading,
                    largePageDataBytes:
                      nextConfig.experimental.largePageDataBytes,
                    // Only the `publicRuntimeConfig` key is exposed to the client side
                    // It'll be rendered as part of __NEXT_DATA__ on the client side
                    runtimeConfig:
                      Object.keys(publicRuntimeConfig).length > 0
                        ? publicRuntimeConfig
                        : undefined,

                    isExperimentalCompile,

                    experimental: {
                      clientTraceMetadata:
                        nextConfig.experimental.clientTraceMetadata ||
                        ([] as any),
                    },

                    locale,
                    locales,
                    defaultLocale,
                    setIsrStatus: routerServerContext?.setIsrStatus,

                    isNextDataRequest:
                      isNextDataRequest && (hasServerProps || hasStaticProps),

                    resolvedUrl,
                    // For getServerSideProps and getInitialProps we need to ensure we use the original URL
                    // and not the resolved URL to prevent a hydration mismatch on
                    // asPath
                    resolvedAsPath:
                      hasServerProps || hasGetInitialProps
                        ? formatUrl({
                            // we use the original URL pathname less the _next/data prefix if
                            // present
                            pathname: isNextDataRequest
                              ? normalizeDataPath(originalPathname)
                              : originalPathname,
                            query: originalQuery,
                          })
                        : resolvedUrl,

                    isOnDemandRevalidate,

                    ErrorDebug: getRequestMeta(req, 'PagesErrorDebug'),
                    err: getRequestMeta(req, 'invokeError'),
                    dev: routeModule.isDev,

                    // needed for experimental.optimizeCss feature
                    distDir: path.join(
                      /* turbopackIgnore: true */
                      process.cwd(),
                      routeModule.relativeProjectDir,
                      routeModule.distDir
                    ),

                    ampSkipValidation:
                      nextConfig.experimental.amp?.skipValidation,
                    ampValidator: getRequestMeta(req, 'ampValidator'),
                  },
                })
                .then((renderResult): ResponseCacheEntry => {
                  const { metadata } = renderResult

                  let cacheControl: CacheControl | undefined =
                    metadata.cacheControl

                  if ('isNotFound' in metadata && metadata.isNotFound) {
                    return {
                      value: null,
                      cacheControl,
                    } satisfies ResponseCacheEntry
                  }

                  // Handle `isRedirect`.
                  if (metadata.isRedirect) {
                    return {
                      value: {
                        kind: CachedRouteKind.REDIRECT,
                        props: metadata.pageData ?? metadata.flightData,
                      } satisfies CachedRedirectValue,
                      cacheControl,
                    } satisfies ResponseCacheEntry
                  }

                  return {
                    value: {
                      kind: CachedRouteKind.PAGES,
                      html: renderResult,
                      pageData: renderResult.metadata.pageData,
                      headers: renderResult.metadata.headers,
                      status: renderResult.metadata.statusCode,
                    },
                    cacheControl,
                  }
                })
                .finally(() => {
                  if (!span) return

                  span.setAttributes({
                    'http.status_code': res.statusCode,
                    'next.rsc': false,
                  })

                  const rootSpanAttributes = tracer.getRootSpanAttributes()
                  // We were unable to get attributes, probably OTEL is not enabled
                  if (!rootSpanAttributes) {
                    return
                  }

                  if (
                    rootSpanAttributes.get('next.span_type') !==
                    BaseServerSpan.handleRequest
                  ) {
                    console.warn(
                      `Unexpected root span type '${rootSpanAttributes.get(
                        'next.span_type'
                      )}'. Please report this Next.js issue https://github.com/vercel/next.js`
                    )
                    return
                  }

                  const route = rootSpanAttributes.get('next.route')
                  if (route) {
                    const name = `${method} ${route}`

                    span.setAttributes({
                      'next.route': route,
                      'http.route': route,
                      'next.span_name': name,
                    })
                    span.updateName(name)
                  } else {
                    span.updateName(`${method} ${req.url}`)
                  }
                })
            } catch (err: unknown) {
              // if this is a background revalidate we need to report
              // the request error here as it won't be bubbled
              if (previousCacheEntry?.isStale) {
                await routeModule.onRequestError(
                  req,
                  err,
                  {
                    routerKind: 'Pages Router',
                    routePath: srcPage,
                    routeType: 'render',
                    revalidateReason: getRevalidateReason({
                      isRevalidate: hasStaticProps,
                      isOnDemandRevalidate,
                    }),
                  },
                  routerServerContext
                )
              }
              throw err
            }
          }

          // if we've already generated this page we no longer
          // serve the fallback
          if (previousCacheEntry) {
            isIsrFallback = false
          }

          if (isIsrFallback) {
            const fallbackResponse = await routeModule
              .getResponseCache(req)
              .get(
                routeModule.isDev
                  ? null
                  : locale
                    ? `/${locale}${srcPage}`
                    : srcPage,
                async ({
                  previousCacheEntry: previousFallbackCacheEntry = null,
                }) => {
                  if (!routeModule.isDev) {
                    return toResponseCacheEntry(previousFallbackCacheEntry)
                  }
                  return doRender()
                },
                {
                  routeKind: RouteKind.PAGES,
                  isFallback: true,
                  isRoutePPREnabled: false,
                  isOnDemandRevalidate: false,
                  incrementalCache: await routeModule.getIncrementalCache(
                    req,
                    nextConfig,
                    prerenderManifest
                  ),
                  waitUntil: ctx.waitUntil,
                }
              )
            if (fallbackResponse) {
              // Remove the cache control from the response to prevent it from being
              // used in the surrounding cache.
              delete fallbackResponse.cacheControl
              fallbackResponse.isMiss = true
              return fallbackResponse
            }
          }

          if (
            !getRequestMeta(req, 'minimalMode') &&
            isOnDemandRevalidate &&
            revalidateOnlyGenerated &&
            !previousCacheEntry
          ) {
            res.statusCode = 404
            // on-demand revalidate always sets this header
            res.setHeader('x-nextjs-cache', 'REVALIDATED')
            res.end('This page could not be found')
            return null
          }

          if (
            isIsrFallback &&
            previousCacheEntry?.value?.kind === CachedRouteKind.PAGES
          ) {
            return {
              value: {
                kind: CachedRouteKind.PAGES,
                html: new RenderResult(
                  Buffer.from(previousCacheEntry.value.html),
                  {
                    contentType: HTML_CONTENT_TYPE_HEADER,
                    metadata: {
                      statusCode: previousCacheEntry.value.status,
                      headers: previousCacheEntry.value.headers,
                    },
                  }
                ),
                pageData: {},
                status: previousCacheEntry.value.status,
                headers: previousCacheEntry.value.headers,
              } satisfies CachedPageValue,
              cacheControl: { revalidate: 0, expire: undefined },
            } satisfies ResponseCacheEntry
          }
          return doRender()
        }

        const result = await routeModule.handleResponse({
          cacheKey,
          req,
          nextConfig,
          routeKind: RouteKind.PAGES,
          isOnDemandRevalidate,
          revalidateOnlyGenerated,
          waitUntil: ctx.waitUntil,
          responseGenerator: responseGenerator,
          prerenderManifest,
        })

        // if we got a cache hit this wasn't an ISR fallback
        // but it wasn't generated during build so isn't in the
        // prerender-manifest
        if (isIsrFallback && !result?.isMiss) {
          isIsrFallback = false
        }

        // response is finished is no cache entry
        if (!result) {
          return
        }

        if (hasStaticProps && !getRequestMeta(req, 'minimalMode')) {
          res.setHeader(
            'x-nextjs-cache',
            isOnDemandRevalidate
              ? 'REVALIDATED'
              : result.isMiss
                ? 'MISS'
                : result.isStale
                  ? 'STALE'
                  : 'HIT'
          )
        }

        let cacheControl: CacheControl | undefined

        if (!hasStaticProps || isIsrFallback) {
          if (!res.getHeader('Cache-Control')) {
            cacheControl = { revalidate: 0, expire: undefined }
          }
        } else if (is404Page) {
          const notFoundRevalidate = getRequestMeta(req, 'notFoundRevalidate')

          cacheControl = {
            revalidate:
              typeof notFoundRevalidate === 'undefined'
                ? 0
                : notFoundRevalidate,
            expire: undefined,
          }
        } else if (is500Page) {
          cacheControl = { revalidate: 0, expire: undefined }
        } else if (result.cacheControl) {
          // If the cache entry has a cache control with a revalidate value that's
          // a number, use it.
          if (typeof result.cacheControl.revalidate === 'number') {
            if (result.cacheControl.revalidate < 1) {
              throw new Error(
                `Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`
              )
            }
            cacheControl = {
              revalidate: result.cacheControl.revalidate,
              expire: result.cacheControl?.expire ?? nextConfig.expireTime,
            }
          } else {
            // revalidate: false
            cacheControl = {
              revalidate: CACHE_ONE_YEAR,
              expire: undefined,
            }
          }
        }

        // If cache control is already set on the response we don't
        // override it to allow users to customize it via next.config
        if (cacheControl && !res.getHeader('Cache-Control')) {
          res.setHeader('Cache-Control', getCacheControlHeader(cacheControl))
        }

        // notFound: true case
        if (!result.value) {
          // add revalidate metadata before rendering 404 page
          // so that we can use this as source of truth for the
          // cache-control header instead of what the 404 page returns
          // for the revalidate value
          addRequestMeta(
            req,
            'notFoundRevalidate',
            result.cacheControl?.revalidate
          )

          res.statusCode = 404

          if (isNextDataRequest) {
            res.end('{"notFound":true}')
            return
          }
          // TODO: should route-module itself handle rendering the 404
          if (routerServerContext?.render404) {
            await routerServerContext.render404(req, res, parsedUrl, false)
          } else {
            res.end('This page could not be found')
          }
          return
        }

        if (result.value.kind === CachedRouteKind.REDIRECT) {
          if (isNextDataRequest) {
            res.setHeader('content-type', JSON_CONTENT_TYPE_HEADER)
            res.end(JSON.stringify(result.value.props))
            return
          } else {
            const handleRedirect = (pageData: any) => {
              const redirect = {
                destination: pageData.pageProps.__N_REDIRECT,
                statusCode: pageData.pageProps.__N_REDIRECT_STATUS,
                basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH,
              }
              const statusCode = getRedirectStatus(redirect)
              const { basePath } = nextConfig

              if (
                basePath &&
                redirect.basePath !== false &&
                redirect.destination.startsWith('/')
              ) {
                redirect.destination = `${basePath}${redirect.destination}`
              }

              if (redirect.destination.startsWith('/')) {
                redirect.destination = normalizeRepeatedSlashes(
                  redirect.destination
                )
              }

              res.statusCode = statusCode
              res.setHeader('Location', redirect.destination)
              if (statusCode === RedirectStatusCode.PermanentRedirect) {
                res.setHeader('Refresh', `0;url=${redirect.destination}`)
              }
              res.end(redirect.destination)
            }
            await handleRedirect(result.value.props)
            return null
          }
        }

        if (result.value.kind !== CachedRouteKind.PAGES) {
          throw new Error(
            `Invariant: received non-pages cache entry in pages handler`
          )
        }

        // In dev, we should not cache pages for any reason.
        if (routeModule.isDev) {
          res.setHeader('Cache-Control', 'no-store, must-revalidate')
        }

        // Draft mode should never be cached
        if (isDraftMode) {
          res.setHeader(
            'Cache-Control',
            'private, no-cache, no-store, max-age=0, must-revalidate'
          )
        }

        // when invoking _error before pages/500 we don't actually
        // send the _error response
        if (
          getRequestMeta(req, 'customErrorRender') ||
          (isErrorPage &&
            getRequestMeta(req, 'minimalMode') &&
            res.statusCode === 500)
        ) {
          return null
        }

        await sendRenderResult({
          req,
          res,
          // If we are rendering the error page it's not a data request
          // anymore
          result:
            isNextDataRequest && !isErrorPage && !is500Page
              ? new RenderResult(
                  Buffer.from(JSON.stringify(result.value.pageData)),
                  {
                    contentType: JSON_CONTENT_TYPE_HEADER,
                    metadata: result.value.html.metadata,
                  }
                )
              : result.value.html,
          generateEtags: nextConfig.generateEtags,
          poweredByHeader: nextConfig.poweredByHeader,
          cacheControl: routeModule.isDev ? undefined : cacheControl,
        })
      }

      // TODO: activeSpan code path is for when wrapped by
      // next-server can be removed when this is no longer used
      if (activeSpan) {
        await handleResponse()
      } else {
        await tracer.withPropagatedContext(req.headers, () =>
          tracer.trace(
            BaseServerSpan.handleRequest,
            {
              spanName: `${method} ${req.url}`,
              kind: SpanKind.SERVER,
              attributes: {
                'http.method': method,
                'http.target': req.url,
              },
            },
            handleResponse
          )
        )
      }
    } catch (err) {
      if (!(err instanceof NoFallbackError)) {
        await routeModule.onRequestError(
          req,
          err,
          {
            routerKind: 'Pages Router',
            routePath: srcPage,
            routeType: 'render',
            revalidateReason: getRevalidateReason({
              isRevalidate: hasStaticProps,
              isOnDemandRevalidate,
            }),
          },
          routerServerContext
        )
      }

      // rethrow so that we can handle serving error page
      throw err
    }
  }
}

	import type { IncomingMessage, ServerResponse } from 'node:http'
	import type { ParsedUrlQuery } from 'node:querystring'
	import { RouteKind } from '../../route-kind'
	import { BaseServerSpan } from '../../lib/trace/constants'
	import { getTracer, SpanKind, type Span } from '../../lib/trace/tracer'
	import { formatUrl } from '../../../shared/lib/router/utils/format-url'
	import { addRequestMeta, getRequestMeta } from '../../request-meta'
	import { interopDefault } from '../../app-render/interop-default'
	import { getRevalidateReason } from '../../instrumentation/utils'
	import { normalizeDataPath } from '../../../shared/lib/page-path/normalize-data-path'
	import {
	CachedRouteKind,
	type CachedPageValue,
	type CachedRedirectValue,
	type ResponseCacheEntry,
	type ResponseGenerator,
	} from '../../response-cache'

	import {
	getCacheControlHeader,
	type CacheControl,
	} from '../../lib/cache-control'
	import { normalizeRepeatedSlashes } from '../../../shared/lib/utils'
	import { getRedirectStatus } from '../../../lib/redirect-status'
	import {
	CACHE_ONE_YEAR,
	HTML_CONTENT_TYPE_HEADER,
	JSON_CONTENT_TYPE_HEADER,
	} from '../../../lib/constants'
	import path from 'path'
	import { sendRenderResult } from '../../send-payload'
	import RenderResult from '../../render-result'
	import { toResponseCacheEntry } from '../../response-cache/utils'
	import { NoFallbackError } from '../../../shared/lib/no-fallback-error.external'
	import { RedirectStatusCode } from '../../../client/components/redirect-status-code'
	import { isBot } from '../../../shared/lib/router/utils/is-bot'
	import { addPathPrefix } from '../../../shared/lib/router/utils/add-path-prefix'
	import { removeTrailingSlash } from '../../../shared/lib/router/utils/remove-trailing-slash'
	import type { PagesRouteModule } from './module.compiled'
	import type {
	GetServerSideProps,
	GetStaticPaths,
	GetStaticProps,
	} from '../../../types'

	export const getHandler = ({
	srcPage: originalSrcPage,
	config,
	userland,
	routeModule,
	isFallbackError,
	getStaticPaths,
	getStaticProps,
	getServerSideProps,
	}: {
	srcPage: string
	config: Record<string, any> \| undefined
	userland: any
	isFallbackError?: boolean
	routeModule: PagesRouteModule
	getStaticProps?: GetStaticProps
	getStaticPaths?: GetStaticPaths
	getServerSideProps?: GetServerSideProps
	}) => {
	return async function handler(
	req: IncomingMessage,
	res: ServerResponse,
	ctx: {
	waitUntil: (prom: Promise<void>) => void
	}
	): Promise<void> {
	let srcPage = originalSrcPage
	// turbopack doesn't normalize `/index` in the page name
	// so we need to to process dynamic routes properly
	// TODO: fix turbopack providing differing value from webpack
	if (process.env.TURBOPACK) {
	srcPage = srcPage.replace(/\/index$/, '') \|\| '/'
	} else if (srcPage === '/index') {
	// we always normalize /index specifically
	srcPage = '/'
	}
	const multiZoneDraftMode = process.env
	.__NEXT_MULTI_ZONE_DRAFT_MODE as any as boolean

	const prepareResult = await routeModule.prepare(req, res, {
	srcPage,
	multiZoneDraftMode,
	})

	if (!prepareResult) {
	res.statusCode = 400
	res.end('Bad Request')
	ctx.waitUntil?.(Promise.resolve())
	return
	}

	const {
	buildId,
	query,
	params,
	parsedUrl,
	originalQuery,
	originalPathname,
	buildManifest,
	fallbackBuildManifest,
	nextFontManifest,
	serverFilesManifest,
	reactLoadableManifest,
	prerenderManifest,
	isDraftMode,
	isOnDemandRevalidate,
	revalidateOnlyGenerated,
	locale,
	locales,
	defaultLocale,
	routerServerContext,
	nextConfig,
	resolvedPathname,
	} = prepareResult

	const isExperimentalCompile =
	serverFilesManifest?.config?.experimental?.isExperimentalCompile

	const hasServerProps = Boolean(getServerSideProps)
	const hasStaticProps = Boolean(getStaticProps)
	const hasStaticPaths = Boolean(getStaticPaths)
	const hasGetInitialProps = Boolean(
	(userland.default \|\| userland).getInitialProps
	)
	const isAmp = query.amp && config?.amp
	let cacheKey: null \| string = null
	let isIsrFallback = false
	let isNextDataRequest =
	prepareResult.isNextDataRequest && (hasStaticProps \|\| hasServerProps)

	const is404Page = srcPage === '/404'
	const is500Page = srcPage === '/500'
	const isErrorPage = srcPage === '/_error'

	if (!routeModule.isDev && !isDraftMode && hasStaticProps) {
	cacheKey = `${locale ? `/${locale}` : ''}${
	(srcPage === '/' \|\| resolvedPathname === '/') && locale
	? ''
	: resolvedPathname
	}${isAmp ? '.amp' : ''}`

	if (is404Page \|\| is500Page \|\| isErrorPage) {
	cacheKey = `${locale ? `/${locale}` : ''}${srcPage}${isAmp ? '.amp' : ''}`
	}

	// ensure /index and / is normalized to one key
	cacheKey = cacheKey === '/index' ? '/' : cacheKey
	}

	if (hasStaticPaths && !isDraftMode) {
	const decodedPathname = removeTrailingSlash(
	locale
	? addPathPrefix(resolvedPathname, `/${locale}`)
	: resolvedPathname
	)
	const isPrerendered =
	Boolean(prerenderManifest.routes[decodedPathname]) \|\|
	prerenderManifest.notFoundRoutes.includes(decodedPathname)

	const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage]

	if (prerenderInfo) {
	if (prerenderInfo.fallback === false && !isPrerendered) {
	throw new NoFallbackError()
	}

	if (
	typeof prerenderInfo.fallback === 'string' &&
	!isPrerendered &&
	!isNextDataRequest
	) {
	isIsrFallback = true
	}
	}
	}

	// When serving a bot request, we want to serve a blocking render and not
	// the prerendered page. This ensures that the correct content is served
	// to the bot in the head.
	if (
	(isIsrFallback && isBot(req.headers['user-agent'] \|\| '')) \|\|
	getRequestMeta(req, 'minimalMode')
	) {
	isIsrFallback = false
	}

	const tracer = getTracer()
	const activeSpan = tracer.getActiveScopeSpan()

	try {
	const method = req.method \|\| 'GET'

	const resolvedUrl = formatUrl({
	pathname: nextConfig.trailingSlash
	? parsedUrl.pathname
	: removeTrailingSlash(parsedUrl.pathname \|\| '/'),
	// make sure to only add query values from original URL
	query: hasStaticProps ? {} : originalQuery,
	})

	const publicRuntimeConfig: Record<string, string> =
	routerServerContext?.publicRuntimeConfig \|\|
	nextConfig.publicRuntimeConfig

	const handleResponse = async (span?: Span) => {
	const responseGenerator: ResponseGenerator = async ({
	previousCacheEntry,
	}) => {
	const doRender = async () => {
	try {
	return await routeModule
	.render(req, res, {
	query:
	hasStaticProps && !isExperimentalCompile
	? ({
	...params,
	...(isAmp
	? {
	amp: query.amp,
	}
	: {}),
	} as ParsedUrlQuery)
	: {
	...query,
	...params,
	},
	params,
	page: srcPage,
	renderContext: {
	isDraftMode,
	isFallback: isIsrFallback,
	developmentNotFoundSourcePage: getRequestMeta(
	req,
	'developmentNotFoundSourcePage'
	),
	},
	sharedContext: {
	buildId,
	customServer:
	Boolean(routerServerContext?.isCustomServer) \|\| undefined,
	deploymentId: process.env.NEXT_DEPLOYMENT_ID,
	},
	renderOpts: {
	params,
	routeModule,
	page: srcPage,
	pageConfig: config \|\| {},
	Component: interopDefault(userland),
	ComponentMod: userland,
	getStaticProps,
	getStaticPaths,
	getServerSideProps,
	supportsDynamicResponse: !hasStaticProps,
	buildManifest: isFallbackError
	? fallbackBuildManifest
	: buildManifest,
	nextFontManifest,
	reactLoadableManifest,

	assetPrefix: nextConfig.assetPrefix,
	previewProps: prerenderManifest.preview,
	images: nextConfig.images as any,
	nextConfigOutput: nextConfig.output,
	optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
	nextScriptWorkers: Boolean(
	nextConfig.experimental.nextScriptWorkers
	),
	domainLocales: nextConfig.i18n?.domains,
	crossOrigin: nextConfig.crossOrigin,

	multiZoneDraftMode,
	basePath: nextConfig.basePath,
	canonicalBase: nextConfig.amp.canonicalBase \|\| '',
	ampOptimizerConfig: nextConfig.experimental.amp?.optimizer,
	disableOptimizedLoading:
	nextConfig.experimental.disableOptimizedLoading,
	largePageDataBytes:
	nextConfig.experimental.largePageDataBytes,
	// Only the `publicRuntimeConfig` key is exposed to the client side
	// It'll be rendered as part of __NEXT_DATA__ on the client side
	runtimeConfig:
	Object.keys(publicRuntimeConfig).length > 0
	? publicRuntimeConfig
	: undefined,

	isExperimentalCompile,

	experimental: {
	clientTraceMetadata:
	nextConfig.experimental.clientTraceMetadata \|\|
	([] as any),
	},

	locale,
	locales,
	defaultLocale,
	setIsrStatus: routerServerContext?.setIsrStatus,

	isNextDataRequest:
	isNextDataRequest && (hasServerProps \|\| hasStaticProps),

	resolvedUrl,
	// For getServerSideProps and getInitialProps we need to ensure we use the original URL
	// and not the resolved URL to prevent a hydration mismatch on
	// asPath
	resolvedAsPath:
	hasServerProps \|\| hasGetInitialProps
	? formatUrl({
	// we use the original URL pathname less the _next/data prefix if
	// present
	pathname: isNextDataRequest
	? normalizeDataPath(originalPathname)
	: originalPathname,
	query: originalQuery,
	})
	: resolvedUrl,

	isOnDemandRevalidate,

	ErrorDebug: getRequestMeta(req, 'PagesErrorDebug'),
	err: getRequestMeta(req, 'invokeError'),
	dev: routeModule.isDev,

	// needed for experimental.optimizeCss feature
	distDir: path.join(
	/* turbopackIgnore: true */
	process.cwd(),
	routeModule.relativeProjectDir,
	routeModule.distDir
	),

	ampSkipValidation:
	nextConfig.experimental.amp?.skipValidation,
	ampValidator: getRequestMeta(req, 'ampValidator'),
	},
	})
	.then((renderResult): ResponseCacheEntry => {
	const { metadata } = renderResult

	let cacheControl: CacheControl \| undefined =
	metadata.cacheControl

	if ('isNotFound' in metadata && metadata.isNotFound) {
	return {
	value: null,
	cacheControl,
	} satisfies ResponseCacheEntry
	}

	// Handle `isRedirect`.
	if (metadata.isRedirect) {
	return {
	value: {
	kind: CachedRouteKind.REDIRECT,
	props: metadata.pageData ?? metadata.flightData,
	} satisfies CachedRedirectValue,
	cacheControl,
	} satisfies ResponseCacheEntry
	}

	return {
	value: {
	kind: CachedRouteKind.PAGES,
	html: renderResult,
	pageData: renderResult.metadata.pageData,
	headers: renderResult.metadata.headers,
	status: renderResult.metadata.statusCode,
	},
	cacheControl,
	}
	})
	.finally(() => {
	if (!span) return

	span.setAttributes({
	'http.status_code': res.statusCode,
	'next.rsc': false,
	})

	const rootSpanAttributes = tracer.getRootSpanAttributes()
	// We were unable to get attributes, probably OTEL is not enabled
	if (!rootSpanAttributes) {
	return
	}

	if (
	rootSpanAttributes.get('next.span_type') !==
	BaseServerSpan.handleRequest
	) {
	console.warn(
	`Unexpected root span type '${rootSpanAttributes.get(
	'next.span_type'
	)}'. Please report this Next.js issue https://github.com/vercel/next.js`
	)
	return
	}

	const route = rootSpanAttributes.get('next.route')
	if (route) {
	const name = `${method} ${route}`

	span.setAttributes({
	'next.route': route,
	'http.route': route,
	'next.span_name': name,
	})
	span.updateName(name)
	} else {
	span.updateName(`${method} ${req.url}`)
	}
	})
	} catch (err: unknown) {
	// if this is a background revalidate we need to report
	// the request error here as it won't be bubbled
	if (previousCacheEntry?.isStale) {
	await routeModule.onRequestError(
	req,
	err,
	{
	routerKind: 'Pages Router',
	routePath: srcPage,
	routeType: 'render',
	revalidateReason: getRevalidateReason({
	isRevalidate: hasStaticProps,
	isOnDemandRevalidate,
	}),
	},
	routerServerContext
	)
	}
	throw err
	}
	}

	// if we've already generated this page we no longer
	// serve the fallback
	if (previousCacheEntry) {
	isIsrFallback = false
	}

	if (isIsrFallback) {
	const fallbackResponse = await routeModule
	.getResponseCache(req)
	.get(
	routeModule.isDev
	? null
	: locale
	? `/${locale}${srcPage}`
	: srcPage,
	async ({
	previousCacheEntry: previousFallbackCacheEntry = null,
	}) => {
	if (!routeModule.isDev) {
	return toResponseCacheEntry(previousFallbackCacheEntry)
	}
	return doRender()
	},
	{
	routeKind: RouteKind.PAGES,
	isFallback: true,
	isRoutePPREnabled: false,
	isOnDemandRevalidate: false,
	incrementalCache: await routeModule.getIncrementalCache(
	req,
	nextConfig,
	prerenderManifest
	),
	waitUntil: ctx.waitUntil,
	}
	)
	if (fallbackResponse) {
	// Remove the cache control from the response to prevent it from being
	// used in the surrounding cache.
	delete fallbackResponse.cacheControl
	fallbackResponse.isMiss = true
	return fallbackResponse
	}
	}

	if (
	!getRequestMeta(req, 'minimalMode') &&
	isOnDemandRevalidate &&
	revalidateOnlyGenerated &&
	!previousCacheEntry
	) {
	res.statusCode = 404
	// on-demand revalidate always sets this header
	res.setHeader('x-nextjs-cache', 'REVALIDATED')
	res.end('This page could not be found')
	return null
	}

	if (
	isIsrFallback &&
	previousCacheEntry?.value?.kind === CachedRouteKind.PAGES
	) {
	return {
	value: {
	kind: CachedRouteKind.PAGES,
	html: new RenderResult(
	Buffer.from(previousCacheEntry.value.html),
	{
	contentType: HTML_CONTENT_TYPE_HEADER,
	metadata: {
	statusCode: previousCacheEntry.value.status,
	headers: previousCacheEntry.value.headers,
	},
	}
	),
	pageData: {},
	status: previousCacheEntry.value.status,
	headers: previousCacheEntry.value.headers,
	} satisfies CachedPageValue,
	cacheControl: { revalidate: 0, expire: undefined },
	} satisfies ResponseCacheEntry
	}
	return doRender()
	}

	const result = await routeModule.handleResponse({
	cacheKey,
	req,
	nextConfig,
	routeKind: RouteKind.PAGES,
	isOnDemandRevalidate,
	revalidateOnlyGenerated,
	waitUntil: ctx.waitUntil,
	responseGenerator: responseGenerator,
	prerenderManifest,
	})

	// if we got a cache hit this wasn't an ISR fallback
	// but it wasn't generated during build so isn't in the
	// prerender-manifest
	if (isIsrFallback && !result?.isMiss) {
	isIsrFallback = false
	}

	// response is finished is no cache entry
	if (!result) {
	return
	}

	if (hasStaticProps && !getRequestMeta(req, 'minimalMode')) {
	res.setHeader(
	'x-nextjs-cache',
	isOnDemandRevalidate
	? 'REVALIDATED'
	: result.isMiss
	? 'MISS'
	: result.isStale
	? 'STALE'
	: 'HIT'
	)
	}

	let cacheControl: CacheControl \| undefined

	if (!hasStaticProps \|\| isIsrFallback) {
	if (!res.getHeader('Cache-Control')) {
	cacheControl = { revalidate: 0, expire: undefined }
	}
	} else if (is404Page) {
	const notFoundRevalidate = getRequestMeta(req, 'notFoundRevalidate')

	cacheControl = {
	revalidate:
	typeof notFoundRevalidate === 'undefined'
	? 0
	: notFoundRevalidate,
	expire: undefined,
	}
	} else if (is500Page) {
	cacheControl = { revalidate: 0, expire: undefined }
	} else if (result.cacheControl) {
	// If the cache entry has a cache control with a revalidate value that's
	// a number, use it.
	if (typeof result.cacheControl.revalidate === 'number') {
	if (result.cacheControl.revalidate < 1) {
	throw new Error(
	`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`
	)
	}
	cacheControl = {
	revalidate: result.cacheControl.revalidate,
	expire: result.cacheControl?.expire ?? nextConfig.expireTime,
	}
	} else {
	// revalidate: false
	cacheControl = {
	revalidate: CACHE_ONE_YEAR,
	expire: undefined,
	}
	}
	}

	// If cache control is already set on the response we don't
	// override it to allow users to customize it via next.config
	if (cacheControl && !res.getHeader('Cache-Control')) {
	res.setHeader('Cache-Control', getCacheControlHeader(cacheControl))
	}

	// notFound: true case
	if (!result.value) {
	// add revalidate metadata before rendering 404 page
	// so that we can use this as source of truth for the
	// cache-control header instead of what the 404 page returns
	// for the revalidate value
	addRequestMeta(
	req,
	'notFoundRevalidate',
	result.cacheControl?.revalidate
	)

	res.statusCode = 404

	if (isNextDataRequest) {
	res.end('{"notFound":true}')
	return
	}
	// TODO: should route-module itself handle rendering the 404
	if (routerServerContext?.render404) {
	await routerServerContext.render404(req, res, parsedUrl, false)
	} else {
	res.end('This page could not be found')
	}
	return
	}

	if (result.value.kind === CachedRouteKind.REDIRECT) {
	if (isNextDataRequest) {
	res.setHeader('content-type', JSON_CONTENT_TYPE_HEADER)
	res.end(JSON.stringify(result.value.props))
	return
	} else {
	const handleRedirect = (pageData: any) => {
	const redirect = {
	destination: pageData.pageProps.__N_REDIRECT,
	statusCode: pageData.pageProps.__N_REDIRECT_STATUS,
	basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH,
	}
	const statusCode = getRedirectStatus(redirect)
	const { basePath } = nextConfig

	if (
	basePath &&
	redirect.basePath !== false &&
	redirect.destination.startsWith('/')
	) {
	redirect.destination = `${basePath}${redirect.destination}`
	}

	if (redirect.destination.startsWith('/')) {
	redirect.destination = normalizeRepeatedSlashes(
	redirect.destination
	)
	}

	res.statusCode = statusCode
	res.setHeader('Location', redirect.destination)
	if (statusCode === RedirectStatusCode.PermanentRedirect) {
	res.setHeader('Refresh', `0;url=${redirect.destination}`)
	}
	res.end(redirect.destination)
	}
	await handleRedirect(result.value.props)
	return null
	}
	}

	if (result.value.kind !== CachedRouteKind.PAGES) {
	throw new Error(
	`Invariant: received non-pages cache entry in pages handler`
	)
	}

	// In dev, we should not cache pages for any reason.
	if (routeModule.isDev) {
	res.setHeader('Cache-Control', 'no-store, must-revalidate')
	}

	// Draft mode should never be cached
	if (isDraftMode) {
	res.setHeader(
	'Cache-Control',
	'private, no-cache, no-store, max-age=0, must-revalidate'
	)
	}

	// when invoking _error before pages/500 we don't actually
	// send the _error response
	if (
	getRequestMeta(req, 'customErrorRender') \|\|
	(isErrorPage &&
	getRequestMeta(req, 'minimalMode') &&
	res.statusCode === 500)
	) {
	return null
	}

	await sendRenderResult({
	req,
	res,
	// If we are rendering the error page it's not a data request
	// anymore
	result:
	isNextDataRequest && !isErrorPage && !is500Page
	? new RenderResult(
	Buffer.from(JSON.stringify(result.value.pageData)),
	{
	contentType: JSON_CONTENT_TYPE_HEADER,
	metadata: result.value.html.metadata,
	}
	)
	: result.value.html,
	generateEtags: nextConfig.generateEtags,
	poweredByHeader: nextConfig.poweredByHeader,
	cacheControl: routeModule.isDev ? undefined : cacheControl,
	})
	}

	// TODO: activeSpan code path is for when wrapped by
	// next-server can be removed when this is no longer used
	if (activeSpan) {
	await handleResponse()
	} else {
	await tracer.withPropagatedContext(req.headers, () =>
	tracer.trace(
	BaseServerSpan.handleRequest,
	{
	spanName: `${method} ${req.url}`,
	kind: SpanKind.SERVER,
	attributes: {
	'http.method': method,
	'http.target': req.url,
	},
	},
	handleResponse
	)
	)
	}
	} catch (err) {
	if (!(err instanceof NoFallbackError)) {
	await routeModule.onRequestError(
	req,
	err,
	{
	routerKind: 'Pages Router',
	routePath: srcPage,
	routeType: 'render',
	revalidateReason: getRevalidateReason({
	isRevalidate: hasStaticProps,
	isOnDemandRevalidate,
	}),
	},
	routerServerContext
	)
	}

	// rethrow so that we can handle serving error page
	throw err
	}
	}
	}