Fork validator.ts generation

Author: eps1lon

packages/next/src/server/lib/router-utils/route-types-utils.ts

@@ -10,6 +10,7 @@ import {
   generateRouteTypesFile,
   generateLinkTypesFile,
   generateValidatorFile,
+  generateValidatorFileStrict,
 } from './typegen'
 import { tryToParsePath } from '../../../lib/try-to-parse-path'
 import {
@@ -372,13 +373,19 @@ export async function writeRouteTypesManifest(
 
 export async function writeValidatorFile(
   manifest: RouteTypesManifest,
-  filePath: string
+  filePath: string,
+  strict: boolean
 ) {
   const dirname = path.dirname(filePath)
 
   if (!fs.existsSync(dirname)) {
     await fs.promises.mkdir(dirname, { recursive: true })
   }
 
-  await fs.promises.writeFile(filePath, generateValidatorFile(manifest))
+  await fs.promises.writeFile(
+    filePath,
+    strict
+      ? generateValidatorFile(manifest)
+      : generateValidatorFileStrict(manifest)
+  )
 }

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

@@ -649,6 +649,247 @@ ${layoutValidations}
 `
 }
 
+export function generateValidatorFileStrict(
+  routesManifest: RouteTypesManifest
+): string {
+  const generateValidations = (
+    paths: string[],
+    type:
+      | 'AppPageConfig'
+      | 'PagesPageConfig'
+      | 'LayoutConfig'
+      | 'RouteHandlerConfig'
+      | 'ApiRouteConfig',
+    pathToRouteMap?: Map<string, string>
+  ) =>
+    paths
+      .sort()
+      // Only validate TypeScript files - JavaScript files have too many type inference limitations
+      .filter(
+        (filePath) => filePath.endsWith('.ts') || filePath.endsWith('.tsx')
+      )
+      .filter(
+        // Don't include metadata routes or pages
+        // (e.g. /manifest.webmanifest)
+        (filePath) =>
+          type !== 'AppPageConfig' ||
+          filePath.endsWith('page.ts') ||
+          filePath.endsWith('page.tsx')
+      )
+      .map((filePath) => {
+        // Keep the file extension for TypeScript imports to support node16 module resolution
+        const importPath = filePath
+        const route = pathToRouteMap?.get(filePath)
+        const typeWithRoute =
+          route &&
+          (type === 'AppPageConfig' ||
+            type === 'LayoutConfig' ||
+            type === 'RouteHandlerConfig')
+            ? `${type}<${JSON.stringify(route)}>`
+            : type
+
+        // NOTE: we previously used `satisfies` here, but it's not supported by TypeScript 4.8 and below.
+        // If we ever raise the TS minimum version, we can switch back.
+
+        return `// Validate ${filePath}
+{
+  type __IsExpected<Specific extends ${typeWithRoute}> = Specific
+  const handler = {} as typeof import(${JSON.stringify(
+    importPath.replace(/\.tsx?$/, '.js')
+  )})
+  type __Check = __IsExpected<typeof handler>
+  // @ts-ignore
+  type __Unused = __Check
+}`
+      })
+      .join('\n\n')
+
+  // Use direct mappings from the manifest
+
+  // Generate validations for different route types
+  const appPageValidations = generateValidations(
+    Array.from(routesManifest.appPagePaths).sort(),
+    'AppPageConfig',
+    routesManifest.filePathToRoute
+  )
+  const appRouteHandlerValidations = generateValidations(
+    Array.from(routesManifest.appRouteHandlers).sort(),
+    'RouteHandlerConfig',
+    routesManifest.filePathToRoute
+  )
+  const pagesRouterPageValidations = generateValidations(
+    Array.from(routesManifest.pagesRouterPagePaths).sort(),
+    'PagesPageConfig'
+  )
+  const pagesApiRouteValidations = generateValidations(
+    Array.from(routesManifest.pageApiRoutes).sort(),
+    'ApiRouteConfig'
+  )
+  const layoutValidations = generateValidations(
+    Array.from(routesManifest.layoutPaths).sort(),
+    'LayoutConfig',
+    routesManifest.filePathToRoute
+  )
+
+  const hasAppRouteHandlers =
+    Object.keys(routesManifest.appRouteHandlerRoutes).length > 0
+
+  // Build type definitions based on what's actually used
+  let typeDefinitions = ''
+
+  if (appPageValidations) {
+    typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
+  default: React.ComponentType<{ params: Promise<ParamMap[Route]> } & any> | ((props: { params: Promise<ParamMap[Route]> } & any) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`
+  }
+
+  if (pagesRouterPageValidations) {
+    typeDefinitions += `type PagesPageConfig = {
+  default: React.ComponentType<any> | ((props: any) => React.ReactNode | Promise<React.ReactNode> | never | void)
+  getStaticProps?: (context: any) => Promise<any> | any
+  getStaticPaths?: (context: any) => Promise<any> | any
+  getServerSideProps?: (context: any) => Promise<any> | any
+  getInitialProps?: (context: any) => Promise<any> | any
+  /**
+   * Segment configuration for legacy Pages Router pages.
+   * Validated at build-time by parsePagesSegmentConfig.
+   */
+  config?: {
+    maxDuration?: number
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    regions?: string[]
+  }
+}
+
+`
+  }
+
+  if (layoutValidations) {
+    typeDefinitions += `type LayoutConfig<Route extends LayoutRoutes = LayoutRoutes> = {
+  default: React.ComponentType<LayoutProps<Route>> | ((props: LayoutProps<Route>) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`
+  }
+
+  if (appRouteHandlerValidations) {
+    typeDefinitions += `type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRoutes> = {
+  GET?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  POST?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PUT?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PATCH?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  DELETE?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  HEAD?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  OPTIONS?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+}
+
+`
+  }
+
+  if (pagesApiRouteValidations) {
+    typeDefinitions += `type ApiRouteConfig = {
+  default: (req: any, res: any) => ReturnType<NextApiHandler>
+  config?: {
+    api?: {
+      bodyParser?: boolean | { sizeLimit?: string }
+      responseLimit?: string | number | boolean
+      externalResolver?: boolean
+    }
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    maxDuration?: number
+  }
+}
+
+`
+  }
+
+  // Build import statement based on what's actually needed
+  const routeImports = []
+
+  // Only import AppRoutes if there are app pages
+  if (appPageValidations) {
+    routeImports.push('AppRoutes')
+  }
+
+  // Only import LayoutRoutes if there are layouts
+  if (layoutValidations) {
+    routeImports.push('LayoutRoutes')
+  }
+
+  // Only import ParamMap if there are routes that use it
+  if (appPageValidations || layoutValidations || appRouteHandlerValidations) {
+    routeImports.push('ParamMap')
+  }
+
+  if (hasAppRouteHandlers) {
+    routeImports.push('AppRouteHandlerRoutes')
+  }
+
+  const routeImportStatement =
+    routeImports.length > 0
+      ? `import type { ${routeImports.join(', ')} } from "./routes.js"`
+      : ''
+
+  const nextRequestImport = hasAppRouteHandlers
+    ? "import type { NextRequest } from 'next/server.js'\n"
+    : ''
+
+  // Conditionally import types from next/types, merged into a single statement
+  const nextTypes: string[] = []
+  if (pagesApiRouteValidations) {
+    nextTypes.push('NextApiHandler')
+  }
+  if (appPageValidations || layoutValidations) {
+    nextTypes.push('ResolvingMetadata', 'ResolvingViewport')
+  }
+  const nextTypesImport =
+    nextTypes.length > 0
+      ? `import type { ${nextTypes.join(', ')} } from "next/types.js"\n`
+      : ''
+
+  return `// This file is generated automatically by Next.js
+// Do not edit this file manually
+// This file validates that all pages and layouts export the correct types
+
+${routeImportStatement}
+${nextTypesImport}${nextRequestImport}
+${typeDefinitions}
+${appPageValidations}
+
+${appRouteHandlerValidations}
+
+${pagesRouterPageValidations}
+
+${pagesApiRouteValidations}
+
+${layoutValidations}
+`
+}
+
 export function generateRouteTypesFile(
   routesManifest: RouteTypesManifest
 ): string {