feat: support server, cache, root params types

Author: bgub

.vscode/settings.json

@@ -118,5 +118,8 @@
     "${workspaceRoot}/.git-blame-ignore-revs"
   ],
   "astGrep.serverPath": "node_modules/@ast-grep/cli/ast-grep",
-  "rust-analyzer.imports.prefix": "crate"
+  "rust-analyzer.imports.prefix": "crate",
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
 }

packages/next/src/build/index.ts

@@ -223,6 +223,8 @@ import {
   createRouteTypesManifest,
   writeRouteTypesManifest,
   writeValidatorFile,
+  writeServerTypesFile,
+  writeCacheLifeTypesFile,
 } from '../server/lib/router-utils/route-types-utils'
 
 type Fallback = null | boolean | string
@@ -1340,6 +1342,34 @@ export default async function build(
             layoutRoutes = processLayoutRoutes(mappedAppLayouts, dir)
           }
 
+          // Collect layout parameters for root params extraction
+          // Find the root layout (shortest path with dynamic segments)
+          const collectedRootParams: Record<string, string[]> = {}
+
+          // Find layouts that could be root layouts (have dynamic segments)
+          const layoutsWithParams = layoutRoutes
+            .map(({ route }) => {
+              const foundParams = Array.from(
+                route.matchAll(/\[(.*?)\]/g),
+                (match) => match[1]
+              )
+              return { route, params: foundParams }
+            })
+            .filter(({ params }) => params.length > 0)
+
+          // Sort by path depth (ascending) to find the shallowest layout with params
+          layoutsWithParams.sort((a, b) => {
+            const aDepth = a.route.split('/').length
+            const bDepth = b.route.split('/').length
+            return aDepth - bDepth
+          })
+
+          // The root layout is the shallowest layout with dynamic segments
+          if (layoutsWithParams.length > 0) {
+            const rootLayout = layoutsWithParams[0]
+            collectedRootParams[rootLayout.route] = rootLayout.params
+          }
+
           const routeTypesManifest = await createRouteTypesManifest({
             dir,
             pageRoutes,
@@ -1352,12 +1382,39 @@ export default async function build(
             rewrites: config.rewrites,
           })
 
+          // Add collected root params and cache life config to manifest
+          routeTypesManifest.collectedRootParams = collectedRootParams
+          routeTypesManifest.cacheLifeConfig = config.experimental?.cacheLife
+
           await writeRouteTypesManifest(
             routeTypesManifest,
             routeTypesFilePath,
             config
           )
           await writeValidatorFile(routeTypesManifest, validatorFilePath)
+
+          // Generate server types if we have root params
+          if (Object.keys(collectedRootParams).length > 0) {
+            const serverTypesFilePath = path.join(
+              distDir,
+              'types',
+              'server.d.ts'
+            )
+            await writeServerTypesFile(routeTypesManifest, serverTypesFilePath)
+          }
+
+          // Generate cache life types if we have cache life config
+          if (config.experimental?.cacheLife) {
+            const cacheLifeTypesFilePath = path.join(
+              distDir,
+              'types',
+              'cache-life.d.ts'
+            )
+            await writeCacheLifeTypesFile(
+              routeTypesManifest,
+              cacheLifeTypesFilePath
+            )
+          }
         })
 
       // Turbopack already handles conflicting app and page routes.

packages/next/src/build/webpack-config.ts

@@ -51,7 +51,6 @@ import { CopyFilePlugin } from './webpack/plugins/copy-file-plugin'
 import { ClientReferenceManifestPlugin } from './webpack/plugins/flight-manifest-plugin'
 import { FlightClientEntryPlugin as NextFlightClientEntryPlugin } from './webpack/plugins/flight-client-entry-plugin'
 import { RspackFlightClientEntryPlugin } from './webpack/plugins/rspack-flight-client-entry-plugin'
-import { NextTypesPlugin } from './webpack/plugins/next-types-plugin'
 import type {
   Feature,
   SWC_TARGET_TRIPLE,
@@ -319,8 +318,6 @@ export default async function getBaseWebpackConfig(
     pagesDir,
     reactProductionProfiling = false,
     rewrites,
-    originalRewrites,
-    originalRedirects,
     runWebpackSpan,
     appDir,
     middlewareMatchers,
@@ -2142,20 +2139,6 @@ export default async function getBaseWebpackConfig(
               isEdgeServer,
               encryptionKey,
             })),
-      hasAppDir &&
-        !isClient &&
-        new NextTypesPlugin({
-          dir,
-          distDir: config.distDir,
-          appDir,
-          dev,
-          isEdgeServer,
-          pageExtensions: config.pageExtensions,
-          typedRoutes: true, // TODO: I think this does more than just enable typed routes??
-          cacheLifeConfig: config.experimental.cacheLife,
-          originalRewrites,
-          originalRedirects,
-        }),
       !dev &&
         isClient &&
         !!config.experimental.sri?.algorithm &&

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

@@ -10,8 +10,11 @@ import {
   generateRouteTypesFile,
   generateLinkTypesFile,
   generateValidatorFile,
+  generateServerTypesFile,
+  generateCacheLifeTypesFile,
 } from './typegen'
 import { tryToParsePath } from '../../../lib/try-to-parse-path'
+import type { CacheLife } from '../../../server/use-cache/cache-life'
 
 interface RouteInfo {
   path: string
@@ -33,8 +36,12 @@ export interface RouteTypesManifest {
   layoutPaths: Set<string>
   appRouteHandlers: Set<string>
   pageApiRoutes: Set<string>
-  /** Direct mapping from file paths to routes for validation */
+  /** Direct mapping from file paths to routes for validation (resolves intercepting routes) */
   filePathToRoute: Map<string, string>
+  /** Layout parameters for root params extraction */
+  collectedRootParams?: Record<string, string[]>
+  /** Cache life configuration */
+  cacheLifeConfig?: { [profile: string]: CacheLife }
 }
 
 // Convert a custom-route source string (`/blog/:slug`, `/docs/:path*`, ...)
@@ -342,3 +349,53 @@ export async function writeValidatorFile(
 
   await fs.promises.writeFile(filePath, generateValidatorFile(manifest))
 }
+
+export async function writeServerTypesFile(
+  manifest: RouteTypesManifest,
+  filePath: string
+) {
+  const dirname = path.dirname(filePath)
+
+  if (!fs.existsSync(dirname)) {
+    await fs.promises.mkdir(dirname, { recursive: true })
+  }
+
+  // Extract root params from collected layout params
+  if (manifest.collectedRootParams) {
+    // Since we now collect only the actual root layout, we can directly use its params
+    const allRootParams: { param: string; optional: boolean }[] = []
+
+    for (const [, params] of Object.entries(manifest.collectedRootParams)) {
+      for (const param of params) {
+        // All root layout params are required (not optional)
+        // since they define the top-level structure of the app
+        allRootParams.push({ param, optional: false })
+      }
+    }
+
+    if (allRootParams.length > 0) {
+      await fs.promises.writeFile(
+        filePath,
+        generateServerTypesFile(allRootParams)
+      )
+    }
+  }
+}
+
+export async function writeCacheLifeTypesFile(
+  manifest: RouteTypesManifest,
+  filePath: string
+) {
+  const dirname = path.dirname(filePath)
+
+  if (!fs.existsSync(dirname)) {
+    await fs.promises.mkdir(dirname, { recursive: true })
+  }
+
+  if (manifest.cacheLifeConfig) {
+    await fs.promises.writeFile(
+      filePath,
+      generateCacheLifeTypesFile(manifest.cacheLifeConfig)
+    )
+  }
+}