feat: static pre-rendering at build time

packages/vinext/src/build/report.ts

@@ -37,6 +37,20 @@ export interface RouteRow {
 
 // ─── Regex-based export detection ────────────────────────────────────────────
 
+// Shared regex builders — a single source of truth for the fn/var patterns
+// used by both hasNamedExport and isLocallyDefinedExport. Extracting them here
+// prevents the two functions from silently drifting if the pattern is ever
+// updated (e.g. to handle `export declare function` or TypeScript's
+// `export const foo: Foo = ...`).
+
+function makeFnRe(name: string): RegExp {
+  return new RegExp(`(?:^|\\n)\\s*export\\s+(?:async\\s+)?function\\s+${name}\\b`);
+}
+
+function makeVarRe(name: string): RegExp {
+  return new RegExp(`(?:^|\\n)\\s*export\\s+(?:const|let|var)\\s+${name}\\s*[=:]`);
+}
+
 /**
  * Returns true if the source code contains a named export with the given name.
  * Handles all three common export forms:
@@ -46,12 +60,10 @@ export interface RouteRow {
  */
 export function hasNamedExport(code: string, name: string): boolean {
   // Function / generator / async function declaration
-  const fnRe = new RegExp(`(?:^|\\n)\\s*export\\s+(?:async\\s+)?function\\s+${name}\\b`);
-  if (fnRe.test(code)) return true;
+  if (makeFnRe(name).test(code)) return true;
 
   // Variable declaration (const / let / var)
-  const varRe = new RegExp(`(?:^|\\n)\\s*export\\s+(?:const|let|var)\\s+${name}\\s*[=:]`);
-  if (varRe.test(code)) return true;
+  if (makeVarRe(name).test(code)) return true;
 
   // Re-export specifier: export { foo } or export { foo as bar }
   const reRe = new RegExp(`export\\s*\\{[^}]*\\b${name}\\b[^}]*\\}`);
@@ -60,6 +72,30 @@ export function hasNamedExport(code: string, name: string): boolean {
   return false;
 }
 
+/**
+ * Returns true if the source code contains a named export that is locally
+ * defined in this file (function declaration or variable assignment), as
+ * opposed to a re-export from another module (`export { foo } from '...'`).
+ *
+ * This distinction matters for `getStaticProps`: a locally-defined
+ * `getStaticProps` has its `revalidate` value readable in this file.
+ * A re-exported one (`export { getStaticProps } from './data'`) has its
+ * implementation in another module — we cannot inspect its revalidate value.
+ *
+ * Uses the same fn/var regex builders as `hasNamedExport` (via `makeFnRe` /
+ * `makeVarRe`) so the two functions always use identical patterns.
+ * Deliberately excludes the re-export `{ foo }` branch.
+ */
+export function isLocallyDefinedExport(code: string, name: string): boolean {
+  // Function / generator / async function declaration
+  if (makeFnRe(name).test(code)) return true;
+
+  // Variable declaration (const / let / var).
+  // Note: intentionally omits the re-export `export { name }` form — that
+  // indicates the implementation lives in another module, not locally here.
+  return makeVarRe(name).test(code);
+}
+
 /**
  * Extracts the string value of `export const <name> = "value"`.
  * Handles optional TypeScript type annotations:
@@ -146,6 +182,15 @@ export function classifyPagesRoute(filePath: string): {
   }
 
   if (hasNamedExport(code, "getStaticProps")) {
+    // If getStaticProps is a re-export from another module (e.g.
+    // `export { getStaticProps } from './data'`), the revalidate value lives in
+    // that other module — we cannot inspect it here. Conservatively treat
+    // re-exported getStaticProps as ISR so the page is skipped during
+    // pre-rendering rather than pinned with a year-long cache header.
+    if (!isLocallyDefinedExport(code, "getStaticProps")) {
+      return { type: "isr" };
+    }
+
     const revalidate = extractGetStaticPropsRevalidate(code);
 
     if (revalidate === null || revalidate === false || revalidate === Infinity) {
@@ -221,25 +266,41 @@ export function classifyAppRoute(
 /**
  * Builds a sorted list of RouteRow objects from the discovered routes.
  * Routes are sorted alphabetically by path, matching filesystem order.
+ *
+ * @param options.knownRoutes - Optional map of pattern → classification override.
+ *   When provided, entries from this map take precedence over the regex-based
+ *   analysis for matching routes. Used to pass in confirmed classifications from
+ *   the static export or pre-render phase (which has runtime-verified knowledge
+ *   of route types), replacing "unknown" with accurate data.
  */
 export function buildReportRows(options: {
   pageRoutes?: Route[];
   apiRoutes?: Route[];
   appRoutes?: AppRoute[];
+  knownRoutes?: Map<string, { type: RouteType; revalidate?: number }>;
 }): RouteRow[] {
   const rows: RouteRow[] = [];
+  const known = options.knownRoutes;
 
   for (const route of options.pageRoutes ?? []) {
-    const { type, revalidate } = classifyPagesRoute(route.filePath);
+    const override = known?.get(route.pattern);
+    const { type, revalidate } = override ?? classifyPagesRoute(route.filePath);
     rows.push({ pattern: route.pattern, type, revalidate });
   }
 
   for (const route of options.apiRoutes ?? []) {
-    rows.push({ pattern: route.pattern, type: "api" });
+    const override = known?.get(route.pattern);
+    rows.push({
+      pattern: route.pattern,
+      type: override?.type ?? "api",
+      revalidate: override?.revalidate,
+    });
   }
 
   for (const route of options.appRoutes ?? []) {
-    const { type, revalidate } = classifyAppRoute(route.pagePath, route.routePath, route.isDynamic);
+    const override = known?.get(route.pattern);
+    const { type, revalidate } =
+      override ?? classifyAppRoute(route.pagePath, route.routePath, route.isDynamic);
     rows.push({ pattern: route.pattern, type, revalidate });
   }
 
@@ -336,10 +397,16 @@ function findDir(root: string, ...candidates: string[]): string | null {
  * Next.js-style build report to stdout.
  *
  * Called at the end of `vinext build` in cli.ts.
+ *
+ * @param options.knownRoutes - Optional map of pattern → confirmed classification.
+ *   When provided, these override the regex-based analysis for matching routes.
+ *   Callers should populate this from the static export or pre-render results
+ *   to provide fully accurate route type information.
  */
 export async function printBuildReport(options: {
   root: string;
   pageExtensions?: string[];
+  knownRoutes?: Map<string, { type: RouteType; revalidate?: number }>;
 }): Promise<void> {
   const { root } = options;
 
@@ -352,7 +419,7 @@ export async function printBuildReport(options: {
     // Dynamic import to avoid loading routing code unless needed
     const { appRouter } = await import("../routing/app-router.js");
     const routes = await appRouter(appDir, options.pageExtensions);
-    const rows = buildReportRows({ appRoutes: routes });
+    const rows = buildReportRows({ appRoutes: routes, knownRoutes: options.knownRoutes });
     if (rows.length > 0) {
       console.log("\n" + formatBuildReport(rows, "app"));
     }
@@ -364,7 +431,7 @@ export async function printBuildReport(options: {
       pagesRouter(pagesDir, options.pageExtensions),
       apiRouter(pagesDir, options.pageExtensions),
     ]);
-    const rows = buildReportRows({ pageRoutes, apiRoutes });
+    const rows = buildReportRows({ pageRoutes, apiRoutes, knownRoutes: options.knownRoutes });
     if (rows.length > 0) {
       console.log("\n" + formatBuildReport(rows, "pages"));
     }