@timber-js/app 0.2.0-alpha.10 → 0.2.0-alpha.100

package/src/routing/codegen.ts

@@ -8,36 +8,23 @@
  * No runtime overhead — purely static type generation.
  */
 
-import { existsSync } from 'node:fs';
-import { join, relative, posix } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
 import type { RouteTree, SegmentNode } from './types.js';
-
-/** A single route entry extracted from the segment tree. */
-interface RouteEntry {
-  /** URL path pattern (e.g. "/products/[id]") */
-  urlPath: string;
-  /** Accumulated params from all ancestor dynamic segments */
-  params: ParamEntry[];
-  /** Whether this route has a co-located search-params.ts */
-  hasSearchParams: boolean;
-  /** Absolute path to search-params.ts (for computing relative import paths) */
-  searchParamsAbsPath?: string;
-  /** Whether this is an API route (route.ts) vs page route */
-  isApiRoute: boolean;
-}
-
-interface ParamEntry {
-  name: string;
-  type: 'string' | 'string[]' | 'string[] | undefined';
-}
+import type { ParamEntry, RouteEntry } from './codegen-types.js';
+import {
+  buildCodecChainType,
+  emitResolveSegmentFieldHelper,
+  formatSearchParamsType,
+} from './codegen-shared.js';
+import { formatLinkCatchAllOverloads, formatTypedLinkOverloads } from './link-codegen.js';
 
 /** Options for route map generation. */
 export interface CodegenOptions {
-  /** Absolute path to the app/ directory. Required for search-params.ts detection. */
+  /** Absolute path to the app/ directory. Required for page searchParams detection. */
   appDir?: string;
   /**
    * Absolute path to the directory where the .d.ts file will be written.
-   * Used to compute correct relative import paths for search-params.ts files.
+   * Used to compute correct relative import paths for page files.
    * Defaults to appDir when not provided (preserves backward compat for tests).
    */
   outputDir?: string;
@@ -51,7 +38,7 @@ export interface CodegenOptions {
  */
 export function generateRouteMap(tree: RouteTree, options: CodegenOptions = {}): string {
   const routes: RouteEntry[] = [];
-  collectRoutes(tree.root, [], options.appDir, routes);
+  collectRoutes(tree.root, [], [], routes);
 
   // Sort routes alphabetically for deterministic output
   routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
@@ -71,37 +58,85 @@ export function generateRouteMap(tree: RouteTree, options: CodegenOptions = {}):
 function collectRoutes(
   node: SegmentNode,
   ancestorParams: ParamEntry[],
-  appDir: string | undefined,
+  ancestorParamsFiles: string[],
   routes: RouteEntry[]
 ): void {
-  // Accumulate params from this segment
+  // TIM-834: Identify this segment's own params.ts (if it has a
+  // segmentParams export). The full chain of params.ts files in the
+  // route ancestry is threaded down via `ancestorParamsFiles`; codec
+  // resolution for each ParamEntry is deferred until leaf time so that
+  // descendant params.ts files can override ancestor codecs (closest-
+  // to-leaf wins, matching the runtime semantics of
+  // coerceSegmentParams which walks segments top-down and overwrites
+  // earlier coercions).
+  const ownParamsFile =
+    node.params && fileHasExport(node.params.filePath, 'segmentParams')
+      ? node.params.filePath
+      : undefined;
+
+  // Accumulate params from this segment. We attach `codecFilePaths`
+  // later (at leaf time) using the FULL chain so descendant overrides
+  // are visible. The legacy layout/page fallback is recorded now
+  // because it is per-segment (and does not participate in inheritance).
   const params = [...ancestorParams];
   if (node.paramName) {
+    const legacyFallback = ownParamsFile ? undefined : findLegacyParamsExport(node);
     params.push({
       name: node.paramName,
       type: paramTypeForSegment(node.segmentType),
+      // Codec chain populated at leaf time. We carry the per-segment
+      // legacy fallback (if any) so leaf-time resolution can fall back
+      // to it when no params.ts in the chain declares this key.
+      legacyCodecFilePath: legacyFallback,
     });
   }
 
+  // Extend the chain for descendants of this segment.
+  const nextAncestorFiles = ownParamsFile
+    ? [...ancestorParamsFiles, ownParamsFile]
+    : ancestorParamsFiles;
+
   // Check if this segment is a leaf route (has page or route file)
   const isPage = !!node.page;
   const isApiRoute = !!node.route;
 
   if (isPage || isApiRoute) {
+    // TIM-834 P1 fix: at LEAF time, the full chain of params.ts files
+    // (root-to-leaf) is known. Resolve every ParamEntry's
+    // `codecFilePaths` to the chain in LEAF-FIRST order so the
+    // closest-to-leaf entry is checked first — matching runtime
+    // closest-wins semantics. The chain is shared by all params in the
+    // route, so we compute it once.
+    const leafFirstChain = nextAncestorFiles.length > 0 ? [...nextAncestorFiles].reverse() : [];
+    const resolvedParams: ParamEntry[] = params.map((p) => {
+      const codecFilePaths =
+        leafFirstChain.length > 0
+          ? leafFirstChain
+          : p.legacyCodecFilePath
+            ? [p.legacyCodecFilePath]
+            : undefined;
+      return {
+        name: p.name,
+        type: p.type,
+        codecFilePaths,
+      };
+    });
+
     const entry: RouteEntry = {
       urlPath: node.urlPath,
-      params: [...params],
+      params: resolvedParams,
       hasSearchParams: false,
       isApiRoute,
     };
 
-    // Detect co-located search-params.ts
-    if (appDir && isPage) {
-      const segmentDir = resolveSegmentDir(appDir, node);
-      const searchParamsFile = findSearchParamsFile(segmentDir);
-      if (searchParamsFile) {
+    // Detect searchParams export from params.ts (primary) or page.tsx (fallback)
+    if (isPage) {
+      if (node.params && fileHasExport(node.params.filePath, 'searchParams')) {
+        entry.hasSearchParams = true;
+        entry.searchParamsPagePath = node.params.filePath;
+      } else if (node.page && fileHasExport(node.page.filePath, 'searchParams')) {
         entry.hasSearchParams = true;
-        entry.searchParamsAbsPath = searchParamsFile;
+        entry.searchParamsPagePath = node.page.filePath;
       }
     }
 
@@ -110,12 +145,12 @@ function collectRoutes(
 
   // Recurse into children
   for (const child of node.children) {
-    collectRoutes(child, params, appDir, routes);
+    collectRoutes(child, params, nextAncestorFiles, routes);
   }
 
   // Recurse into slots (they share the parent's URL path, but may have their own pages)
-  for (const [, slot] of node.slots) {
-    collectRoutes(slot, params, appDir, routes);
+  for (const slot of Object.values(node.slots)) {
+    collectRoutes(slot, params, nextAncestorFiles, routes);
   }
 }
 
@@ -134,33 +169,38 @@ function paramTypeForSegment(segmentType: string): ParamEntry['type'] {
 }
 
 /**
- * Resolve the absolute directory path for a segment node.
+ * Check if a file exports a specific named export.
  *
- * Reconstructs the filesystem path by walking from appDir through
- * the segment names encoded in the urlPath, accounting for groups and slots.
+ * Uses a lightweight regex check — not full AST parsing. The actual type
+ * extraction happens via the TypeScript compiler in the generated .d.ts.
  */
-function resolveSegmentDir(appDir: string, node: SegmentNode): string {
-  // The node's page/route file path gives us the actual directory
-  const file = node.page ?? node.route;
-  if (file) {
-    // The file is in the segment directory — go up one level
-    const parts = file.filePath.split('/');
-    parts.pop(); // remove filename
-    return parts.join('/');
+function fileHasExport(filePath: string, exportName: string): boolean {
+  if (!existsSync(filePath)) return false;
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const e = exportName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return (
+      new RegExp(`export\\s+(const|let|var)\\s+${e}\\b`).test(content) ||
+      new RegExp(`export\\s*\\{[^}]*\\b${e}\\b[^}]*\\}`).test(content)
+    );
+  } catch {
+    return false;
   }
-  // Fallback: construct from urlPath (imprecise for groups, but acceptable)
-  return appDir;
 }
 
 /**
- * Find a search-params.ts file in a directory.
+ * Find a legacy `segmentParams` export on layout.tsx or page.tsx.
+ *
+ * Backward-compat shim: TIM-508 made params.ts the canonical location
+ * for `segmentParams`. Layout/page exports are still accepted for the
+ * OWN segment only (not inherited by descendants — see TIM-834).
  */
-function findSearchParamsFile(dirPath: string): string | undefined {
-  for (const ext of ['ts', 'tsx']) {
-    const candidate = join(dirPath, `search-params.${ext}`);
-    if (existsSync(candidate)) {
-      return candidate;
-    }
+function findLegacyParamsExport(node: SegmentNode): string | undefined {
+  if (node.layout && fileHasExport(node.layout.filePath, 'segmentParams')) {
+    return node.layout.filePath;
+  }
+  if (node.page && fileHasExport(node.page.filePath, 'segmentParams')) {
+    return node.page.filePath;
   }
   return undefined;
 }
@@ -180,15 +220,21 @@ function formatDeclarationFile(routes: RouteEntry[], importBase?: string): strin
   // (removing exports like bindUseQueryStates that aren't listed here).
   lines.push('export {};');
   lines.push('');
+
+  // TIM-834 P2: emit the shared codec-resolution helper type ONCE so the
+  // per-param chain conditionals reference it instead of inlining the
+  // fallback in both branches (which grows O(2^N) in chain depth).
+  lines.push(emitResolveSegmentFieldHelper());
+  lines.push('');
   lines.push("declare module '@timber-js/app' {");
   lines.push('  interface Routes {');
 
   for (const route of routes) {
-    const paramsType = formatParamsType(route.params);
+    const paramsType = formatParamsType(route.params, importBase);
     const searchParamsType = formatSearchParamsType(route, importBase);
 
     lines.push(`    '${route.urlPath}': {`);
-    lines.push(`      params: ${paramsType}`);
+    lines.push(`      segmentParams: ${paramsType}`);
     lines.push(`      searchParams: ${searchParamsType}`);
     lines.push(`    }`);
   }
@@ -200,15 +246,9 @@ function formatDeclarationFile(routes: RouteEntry[], importBase?: string): strin
   // Generate @timber-js/app/server augmentation — typed searchParams() generic
   const pageRoutes = routes.filter((r) => !r.isApiRoute);
 
-  if (pageRoutes.length > 0) {
-    lines.push("declare module '@timber-js/app/server' {");
-    lines.push("  import type { Routes } from '@timber-js/app'");
-    lines.push(
-      "  export function searchParams<R extends keyof Routes>(): Promise<Routes[R]['searchParams']>"
-    );
-    lines.push('}');
-    lines.push('');
-  }
+  // Note: searchParams() always returns Promise<URLSearchParams>.
+  // Typed parsing is done via definition.parse(searchParams()).
+  // No module augmentation needed for @timber-js/app/server.
 
   // Generate overloads for @timber-js/app/client
   const dynamicRoutes = routes.filter((r) => r.params.length > 0);
@@ -223,10 +263,10 @@ function formatDeclarationFile(routes: RouteEntry[], importBase?: string): strin
     // useParams overloads
     if (dynamicRoutes.length > 0) {
       for (const route of dynamicRoutes) {
-        const paramsType = formatParamsType(route.params);
-        lines.push(`  export function useParams(route: '${route.urlPath}'): ${paramsType}`);
+        const paramsType = formatParamsType(route.params, importBase);
+        lines.push(`  export function useSegmentParams(route: '${route.urlPath}'): ${paramsType}`);
       }
-      lines.push('  export function useParams(): Record<string, string | string[]>');
+      lines.push('  export function useSegmentParams(): Record<string, string | string[]>');
       lines.push('');
     }
 
@@ -236,78 +276,57 @@ function formatDeclarationFile(routes: RouteEntry[], importBase?: string): strin
       lines.push('');
     }
 
-    // Typed Link overloads
+    // Typed Link overloads — per-route with DIRECT types (no conditionals).
+    // Direct types preserve TypeScript's excess property checking.
+    //
+    // TIM-832: per-route and catch-all are emitted as TWO separate
+    // augmentation blocks. Per TS's merging rule "later overload sets
+    // ordered first", the catch-all block (declared SECOND in this file)
+    // ends up FIRST in the merged call-signature list at resolution time,
+    // which puts the per-route block LAST — so its error message is the
+    // one TypeScript reports when no overload matches. This gives users a
+    // clear prop-mismatch error (e.g. "'string | undefined' is not
+    // assignable to 'string | number' on id") instead of the old
+    // confusing "Type 'string' is not assignable to type 'never'" cascade.
     if (pageRoutes.length > 0) {
-      lines.push('  // Typed Link props per route');
+      lines.push('  // Typed Link overloads — per-route (block 1 / emitted first)');
       lines.push(...formatTypedLinkOverloads(pageRoutes, importBase));
+      lines.push('');
     }
 
     lines.push('}');
     lines.push('');
   }
 
+  // TIM-832: catch-all block — emitted as a SEPARATE `declare module`
+  // augmentation so TS's "later overload set first" rule orders it ahead
+  // of the per-route block above at resolution time, leaving per-route as
+  // the "last overload" whose error TypeScript reports.
+  lines.push("declare module '@timber-js/app/client' {");
+  lines.push("  import type { SearchParamsDefinition } from '@timber-js/app/search-params'");
+  lines.push('');
+  lines.push(...formatLinkCatchAllOverloads());
+  lines.push('}');
+  lines.push('');
+
   return lines.join('\n');
 }
 
 /**
  * Format the params type for a route entry.
  */
-function formatParamsType(params: ParamEntry[]): string {
-  if (params.length === 0) {
-    return '{}';
-  }
-
-  const fields = params.map((p) => `${p.name}: ${p.type}`);
-  return `{ ${fields.join('; ')} }`;
-}
-
-/**
- * Format the params type for Link props.
- *
- * Link params accept `string | number` for single dynamic segments
- * (convenience — values are stringified at runtime). Catch-all and
- * optional catch-all remain `string[]` / `string[] | undefined`.
- *
- * See design/07-routing.md §"Typed params and searchParams on <Link>"
- */
-function formatLinkParamsType(params: ParamEntry[]): string {
+function formatParamsType(params: ParamEntry[], importBase?: string): string {
   if (params.length === 0) {
     return '{}';
   }
 
   const fields = params.map((p) => {
-    // Single dynamic segments accept string | number for convenience
-    const type = p.type === 'string' ? 'string | number' : p.type;
-    return `${p.name}: ${type}`;
+    const codecType = buildCodecChainType(p, importBase, p.type);
+    return `${p.name}: ${codecType}`;
   });
   return `{ ${fields.join('; ')} }`;
 }
 
-/**
- * Format the searchParams type for a route entry.
- *
- * When a search-params.ts exists, we reference its inferred type via an import type.
- * The import path is relative to `importBase` (the directory where the .d.ts will be
- * written). When importBase is undefined, falls back to a bare relative path.
- */
-function formatSearchParamsType(route: RouteEntry, importBase?: string): string {
-  if (route.hasSearchParams && route.searchParamsAbsPath) {
-    const absPath = route.searchParamsAbsPath.replace(/\.(ts|tsx)$/, '');
-    let importPath: string;
-    if (importBase) {
-      // Make the path relative to the output directory, converted to posix separators
-      importPath = './' + relative(importBase, absPath).replace(/\\/g, '/');
-    } else {
-      importPath = './' + posix.basename(absPath);
-    }
-    // Use (typeof import('...'))[' default'] instead of import('...').default
-    // because with moduleResolution:"bundler", import('...').default is treated as
-    // a namespace member access which doesn't work for default exports.
-    return `(typeof import('${importPath}'))['default'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
-  }
-  return '{}';
-}
-
 /**
  * Generate useQueryStates overloads.
  *
@@ -337,60 +356,8 @@ function formatUseQueryStatesOverloads(routes: RouteEntry[], importBase?: string
   return lines;
 }
 
-/**
- * Generate typed Link overloads.
- *
- * For each page route, we generate a Link function overload that:
- * - Constrains href to the route pattern
- * - Types the params prop based on dynamic segments
- * - Types the searchParams prop based on search-params.ts (if present)
- *
- * Routes without dynamic segments accept href as a literal string with no params.
- * Routes with dynamic segments require a params prop.
- */
-function formatTypedLinkOverloads(routes: RouteEntry[], importBase?: string): string[] {
-  const lines: string[] = [];
-
-  for (const route of routes) {
-    const hasDynamicParams = route.params.length > 0;
-    const paramsType = formatLinkParamsType(route.params);
-    const searchParamsType = route.hasSearchParams
-      ? formatSearchParamsType(route, importBase)
-      : null;
-
-    if (hasDynamicParams) {
-      // Route with dynamic segments — params prop required
-      const spProp = searchParamsType
-        ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }`
-        : `searchParams?: never`;
-      lines.push(
-        `  export function Link(props: Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {`
-      );
-      lines.push(`    href: '${route.urlPath}'`);
-      lines.push(`    params: ${paramsType}`);
-      lines.push(`    ${spProp}`);
-      lines.push(`    prefetch?: boolean; scroll?: boolean; children?: import('react').ReactNode`);
-      lines.push(`  }): import('react').JSX.Element`);
-    } else {
-      // Static route — no params needed
-      const spProp = searchParamsType
-        ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }`
-        : `searchParams?: never`;
-      lines.push(
-        `  export function Link(props: Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {`
-      );
-      lines.push(`    href: '${route.urlPath}'`);
-      lines.push(`    params?: never`);
-      lines.push(`    ${spProp}`);
-      lines.push(`    prefetch?: boolean; scroll?: boolean; children?: import('react').ReactNode`);
-      lines.push(`  }): import('react').JSX.Element`);
-    }
-  }
-
-  // Fallback overload for arbitrary string hrefs (escape hatch)
-  lines.push(
-    `  export function Link(props: import('./client/link.js').LinkProps): import('react').JSX.Element`
-  );
-
-  return lines;
-}
+// Link overload formatters and helpers (`formatTypedLinkOverloads`,
+// `formatLinkCatchAllOverloads`, `formatLinkParamsType`,
+// `buildResolvedPattern`, `LINK_BASE_PROPS_TYPE`) were extracted to
+// `./link-codegen.ts` (TIM-835) to keep this file under the 500-line
+// cap. They are imported at the top of this file.