@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

package/src/routing/link-codegen.ts

@@ -0,0 +1,280 @@
+/**
+ * Typed `<Link>` codegen — interface augmentation generation.
+ *
+ * Extracted from `codegen.ts` to keep that file under the project's
+ * 500-line cap. This module owns everything that emits the
+ * `interface LinkFunction { ... }` augmentation blocks in the generated
+ * `.timber/timber-routes.d.ts`.
+ *
+ * Two augmentation blocks are emitted:
+ *
+ * 1. **Per-route discriminated union** (`formatTypedLinkOverloads`) —
+ *    one call signature whose props is a union keyed on `href`. TS
+ *    narrows by literal href and reports prop errors against the
+ *    matched variant. See TIM-835 and `design/09-typescript.md`.
+ *
+ * 2. **Catch-all overloads** (`formatLinkCatchAllOverloads`) — external
+ *    href literals (`http://`, `mailto:`, etc.) and a computed-string
+ *    `<H extends string>` signature for runtime-computed paths.
+ *
+ * Block ordering is critical for error UX: per-route is emitted FIRST
+ * so that, after TS's "later overload set ordered first" merge rule,
+ * the discriminated union ends up LAST in resolution order — the
+ * overload TS reports against on failure.
+ */
+
+import type { ParamEntry, RouteEntry } from './codegen-types.ts';
+import { buildSchemaParamType } from './codegen-shared.ts';
+import { classifyUrlSegment } from './segment-classify.ts';
+
+/**
+ * The `searchParams` prop type, emitted identically on every Link variant
+ * — per-route pattern, resolved template, and catch-all.
+ *
+ * TIM-1343: there is no per-route narrowing any more. `params.ts` is gone,
+ * so codegen has no definition to read a `SearchParamsDefinition<T>` from.
+ * Type safety moved to the value's construction site instead: callers write
+ * `definition.buildSearchParams({ ... })`, which checks `Partial<T>` there
+ * and returns a query STRING — the only shape that survives the RSC Flight
+ * boundary. A plain record is the uncodec'd escape hatch. See `client/link.tsx` §"searchParams prop shapes".
+ *
+ * Declared once so the three emission sites cannot drift apart.
+ */
+export const SEARCH_PARAMS_PROP_TYPE = 'string | Record<string, unknown>';
+
+/** Shared Link base-props type literal used in every emitted call signature. */
+export const LINK_BASE_PROPS_TYPE =
+  "Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & { prefetch?: boolean; scroll?: boolean; preserveSearchParams?: true | string[]; onNavigate?: import('./client/link.js').OnNavigateHandler; children?: import('react').ReactNode }";
+
+/**
+ * Build a TypeScript template literal pattern for a dynamic route.
+ * e.g. '/products/[id]'        → '/products/${string}'
+ *      '/blog/[...slug]'       → '/blog/${string}'
+ *      '/docs/[[...path]]'     → '/docs/${string}' (also matches /docs)
+ *      '/[org]/[repo]'         → '/${string}/${string}'
+ */
+export function buildResolvedPattern(route: RouteEntry): string | null {
+  const parts = route.urlPath.split('/');
+  const templateParts = parts.map((part) => {
+    const seg = classifyUrlSegment(part);
+    switch (seg.kind) {
+      case 'catch-all':
+      case 'optional-catch-all':
+        // eslint-disable-next-line no-template-curly-in-string -- codegen output
+        return '${string}';
+      case 'dynamic': {
+        const prefix = seg.prefix ?? '';
+        const suffix = seg.suffix ?? '';
+        // eslint-disable-next-line no-template-curly-in-string -- codegen output
+        return `${prefix}\${string}${suffix}`;
+      }
+      default:
+        return part;
+    }
+  });
+  return templateParts.join('/');
+}
+
+/**
+ * Format the segmentParams type for Link overloads.
+ *
+ * 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`.
+ *
+ * With a global schema, the schema codec's inferred type wins. Without
+ * one, a URL segment is a raw string (widened to string | number for
+ * Link convenience) — per-segment codec chains were deleted in TIM-1342.
+ */
+export function formatLinkParamsType(params: ParamEntry[], hasSchema?: boolean): string {
+  if (params.length === 0) {
+    return '{}';
+  }
+
+  const fields = params.map((p) => {
+    const fallback = p.type === 'string' ? 'string | number' : p.type;
+    const codecType = hasSchema ? buildSchemaParamType(p, fallback) : fallback;
+    return `${p.name}: ${codecType}`;
+  });
+  return `{ ${fields.join('; ')} }`;
+}
+
+/**
+ * Catch-all call signatures for `<Link>` — external hrefs and computed
+ * `string` variables. Emitted from codegen in a SEPARATE
+ * `declare module` block (declared AFTER the per-route block) so the TS
+ * "later overload set ordered first" rule places these catch-all
+ * signatures ahead of per-route in resolution order, leaving per-route
+ * as the final overload whose error message is reported on failure.
+ *
+ * The conditional `string extends H ? ... : never` protection preserves
+ * TIM-624's guarantee that unknown internal path literals don't match
+ * the catch-all — typos like `<Link href="/typo" />` still error.
+ */
+export function formatLinkCatchAllOverloads(): string[] {
+  const lines: string[] = [];
+  const baseProps = LINK_BASE_PROPS_TYPE;
+
+  const catchAllSearchParams = SEARCH_PARAMS_PROP_TYPE;
+
+  // ExternalHref inlined here rather than referenced as an exported
+  // alias so the generated .d.ts stands alone without source imports.
+  /* eslint-disable no-template-curly-in-string -- codegen output */
+  const externalHref =
+    '`http://${string}` | `https://${string}` | `mailto:${string}` | `tel:${string}` | `ftp://${string}` | `//${string}` | `#${string}` | `?${string}`';
+  /* eslint-enable no-template-curly-in-string */
+
+  lines.push('  // Typed Link overloads — catch-all (block 2 / emitted second)');
+  lines.push('  interface LinkFunction {');
+
+  // (1) External/literal-protocol hrefs.
+  //
+  // TIM-833: `segmentParams` is permissively typed as
+  // `Record<string, unknown>` (not `never`) so generic wrappers that
+  // forward a `LinkProps`-shaped object can compile when the wrapper
+  // happens to bottom out at an external href. There are no dynamic
+  // segments to interpolate for an external href, so this prop is
+  // ignored at runtime — accepting an open-shape object instead of
+  // forbidding it removes a footgun without changing behavior.
+  lines.push(`    (props: ${baseProps} & {`);
+  lines.push(`      href: ${externalHref}`);
+  lines.push(`      segmentParams?: Record<string, unknown>`);
+  lines.push(`      searchParams?: ${catchAllSearchParams}`);
+  lines.push(`    }): import('react').JSX.Element`);
+
+  // (2) Computed/variable href — non-literal `string` only.
+  //
+  // `string extends H` is true only when H is the wide `string` type,
+  // not a specific literal. For literal hrefs, this overload must NOT
+  // be selectable so the per-route discriminated union (block 1) is
+  // the resolution target.
+  //
+  // TIM-833 follow-up: the previous shape used `string extends H ? {...} : never`
+  // on the WHOLE props type. For literal H, that collapsed `props` to
+  // `never`, and JSX type inference then read `(never).children` as
+  // `never` — producing the misleading
+  // `'children' prop expects type 'never' which requires multiple
+  // children, but only a single child was provided` (TS2745) error,
+  // which buried the actual prop-mismatch message under a noise diagnostic.
+  //
+  // Fix: move the `: never` from the whole props onto just the `href`
+  // field. The overload remains uncallable for literal H (since `"/x"`
+  // is not assignable to `never`), but `children` retains its real
+  // `ReactNode` type so JSX inference no longer collapses to never.
+  // The diagnostic surface becomes: TS reports the per-route block's
+  // error chain (the helpful "Type 'number' is not assignable to type
+  // 'string'" message) WITHOUT a leading TS2745 noise line.
+  lines.push(`    <H extends string>(`);
+  lines.push(`      props: ${baseProps} & {`);
+  lines.push(`        href: string extends H ? H : never`);
+  lines.push(`        segmentParams?: Record<string, string | number | string[]>`);
+  lines.push(`        searchParams?: ${catchAllSearchParams}`);
+  lines.push(`      }`);
+  lines.push(`    ): import('react').JSX.Element`);
+
+  lines.push('  }');
+  return lines;
+}
+
+/**
+ * Generate typed per-route Link call signatures via LinkFunction
+ * interface merging.
+ *
+ * TIM-835: This emits a SINGLE call signature whose props is a
+ * discriminated union keyed on `href`. TypeScript narrows the union by
+ * the literal `href` at the call site, then checks the rest of the
+ * props against the matched variant. When `segmentParams` or
+ * `searchParams` is wrong, TS reports the error against the matched
+ * variant — naming the user's actual `href` and the offending field.
+ *
+ * Before TIM-835, this function emitted N separate per-route overloads
+ * (one per route, sometimes two for dynamic routes). When ALL overloads
+ * failed, TS would pick an arbitrary failed overload (heuristically the
+ * "last tried") to render the diagnostic, often pointing at a route
+ * completely unrelated to the one the user wrote. The discriminated
+ * union sidesteps overload-resolution heuristics entirely.
+ *
+ * Open property shapes (`Record<string, unknown>` instead of `never`)
+ * for `segmentParams` on routes that don't declare them keep generic
+ * `LinkProps`-spreading wrappers compiling. (Aligned with TIM-833.)
+ *
+ * TIM-832: this function still emits the per-route block FIRST and the
+ * catch-all block follows, so per-route remains the LAST overload set in
+ * resolution order — the one TS reports against on failure. With a
+ * discriminated union there is only one call signature in this block,
+ * so the resolved-template-vs-pattern ordering reduces to placing the
+ * pattern variant before the resolved-template variant inside the union.
+ */
+export function formatTypedLinkOverloads(routes: RouteEntry[], hasSchema?: boolean): string[] {
+  const lines: string[] = [];
+  const baseProps = LINK_BASE_PROPS_TYPE;
+
+  // Build the union variants. Each route contributes one variant for the
+  // pattern href (e.g. '/products/[id]') and, for dynamic routes, an
+  // additional variant for the resolved-template href (e.g.
+  // `/products/${string}`).
+  //
+  // The PATTERN variant must be listed BEFORE the resolved-template
+  // variant for the same route so that when the user writes the literal
+  // pattern href (`<Link href="/products/[id]" />`), TS narrows to the
+  // pattern variant (which carries the typed `segmentParams` shape)
+  // rather than the looser resolved-template variant. Without this
+  // ordering, TS would silently match the resolved-template variant
+  // first — swallowing typed-segmentParams type errors.
+  const variants: string[] = [];
+  for (const route of routes) {
+    const hasDynamicParams = route.params.length > 0;
+    // For routes with no dynamic params, accept an absent OR open-shape
+    // segmentParams. `Record<string, unknown>` keeps generic spreads
+    // compiling and gives a readable error if a non-object is passed.
+    const paramsProp = hasDynamicParams
+      ? `segmentParams: ${formatLinkParamsType(route.params, hasSchema)}`
+      : 'segmentParams?: Record<string, unknown>';
+
+    // TIM-1343: searchParams is no longer typed per-route. There is no
+    // convention file to read a definition from, so codegen has nothing to
+    // narrow with — the value is either a URLSearchParams built by
+    // `definition.buildSearchParams()` (which type-checks its own
+    // `Partial<T>` at that call) or a plain String()-coerced record.
+    const searchParamsProp = `searchParams?: ${SEARCH_PARAMS_PROP_TYPE}`;
+
+    // Pattern variant FIRST (more specific).
+    variants.push(
+      `${baseProps} & { href: '${route.urlPath}'; ${paramsProp}; ${searchParamsProp} }`
+    );
+
+    // Resolved-template variant SECOND (looser, matches interpolated hrefs).
+    if (hasDynamicParams) {
+      const templatePattern = buildResolvedPattern(route);
+      if (templatePattern) {
+        // TIM-835: `Record<string, never>` for segmentParams forbids ANY
+        // provided keys on the resolved-template variant. Without this,
+        // the resolved-template would shadow the pattern variant for
+        // literal pattern hrefs (`<Link href="/products/[id]" segmentParams={...} />`)
+        // because both variants accept the literal `'/products/[id]'`
+        // and the looser variant would silently swallow segmentParams
+        // type errors.
+        variants.push(
+          `${baseProps} & { href: \`${templatePattern}\`; segmentParams?: Record<string, never>; ${searchParamsProp} }`
+        );
+      }
+    }
+  }
+
+  lines.push('  interface LinkFunction {');
+  if (variants.length === 0) {
+    // No page routes — emit nothing. The catch-all block in the second
+    // augmentation still provides external/computed-string signatures.
+    lines.push('  }');
+    return lines;
+  }
+  lines.push('    (');
+  lines.push('      props:');
+  for (const variant of variants) {
+    lines.push(`        | (${variant})`);
+  }
+  lines.push(`    ): import('react').JSX.Element`);
+  lines.push('  }');
+
+  return lines;
+}

package/src/routing/manifest-codegen.ts

@@ -0,0 +1,232 @@
+/**
+ * Route manifest codegen — generates virtual module source for the route
+ * manifest and the global schema loader.
+ *
+ * Extracted from plugins/routing.ts to keep it under the 500-line budget.
+ * See design/18-build-system.md §"Virtual Modules".
+ *
+ * Task: TIM-1071 item 8
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { collectInterceptionRewrites } from './interception.ts';
+import type { RouteTree, SegmentNode, RouteFile } from './types.ts';
+
+// ── Single-file conventions ─────────────────────────────────────────────
+// Each entry maps to a node property that holds a single RouteFile.
+// Order matches the original serializeNode output for byte-identical diffs.
+const SINGLE_FILE_KEYS = [
+  'page',
+  'layout',
+  'middleware',
+  'access',
+  'route',
+  'error',
+  'default',
+  'denied',
+] as const;
+
+// ── Record-shaped conventions ───────────────────────────────────────────
+// Each entry maps to a node property that holds Record<string, RouteFile>.
+const RECORD_FILE_KEYS = ['statusFiles', 'jsonStatusFiles', 'metadataRoutes'] as const;
+
+const SCHEMA_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+
+// ── Manifest generation ─────────────────────────────────────────────────
+
+/**
+ * Generate the virtual module source for the route manifest.
+ *
+ * The output is a default-exported object containing the serialized route tree.
+ * All file references use absolute paths (required for virtual modules).
+ */
+export function generateManifestModule(tree: RouteTree, viteRoot: string): string {
+  const imports: string[] = [];
+  let importIndex = 0;
+
+  function addImport(file: RouteFile): string {
+    const varName = `_route${importIndex++}`;
+    imports.push(`const ${varName} = () => import("${file.filePath}");`);
+    return varName;
+  }
+
+  function serializeRouteFile(key: string, file: RouteFile, indent: string): string {
+    const v = addImport(file);
+    return `${indent}${key}: { load: ${v}, filePath: ${JSON.stringify(file.filePath)} },`;
+  }
+
+  function serializeRouteFileRecord(
+    key: string,
+    record: Record<string, RouteFile>,
+    indent: string
+  ): string | null {
+    const entries = Object.entries(record);
+    if (entries.length === 0) return null;
+    const inner = entries.map(([name, file]) => {
+      const v = addImport(file);
+      return `${indent}    ${JSON.stringify(name)}: { load: ${v}, filePath: ${JSON.stringify(file.filePath)} }`;
+    });
+    return `${indent}${key}: {\n${inner.join(',\n')}\n${indent}},`;
+  }
+
+  function serializeNode(node: SegmentNode, indent: string): string {
+    const nextIndent = indent + '  ';
+    const parts: string[] = [];
+
+    parts.push(`${nextIndent}segmentName: ${JSON.stringify(node.segmentName)},`);
+    parts.push(`${nextIndent}segmentType: ${JSON.stringify(node.segmentType)},`);
+    parts.push(`${nextIndent}urlPath: ${JSON.stringify(node.urlPath)},`);
+
+    if (node.paramName) {
+      parts.push(`${nextIndent}paramName: ${JSON.stringify(node.paramName)},`);
+    }
+    if (node.paramPrefix) {
+      parts.push(`${nextIndent}paramPrefix: ${JSON.stringify(node.paramPrefix)},`);
+    }
+    if (node.paramSuffix) {
+      parts.push(`${nextIndent}paramSuffix: ${JSON.stringify(node.paramSuffix)},`);
+    }
+
+    if (node.interceptionMarker) {
+      parts.push(`${nextIndent}interceptionMarker: ${JSON.stringify(node.interceptionMarker)},`);
+    }
+    if (node.interceptedSegmentName) {
+      parts.push(
+        `${nextIndent}interceptedSegmentName: ${JSON.stringify(node.interceptedSegmentName)},`
+      );
+    }
+
+    // Single-file conventions — table-driven to avoid copy-paste drift
+    for (const key of SINGLE_FILE_KEYS) {
+      const file = node[key];
+      if (file) {
+        parts.push(serializeRouteFile(key, file, nextIndent));
+      }
+    }
+
+    // Read from route.ts source at scan time; the CSRF gate consults it
+    // before any user module loads (design/08 §"Per-route exemption").
+    if (node.csrfExempt) {
+      parts.push(`${nextIndent}csrfExempt: true,`);
+    }
+
+    // Record-shaped conventions — table-driven
+    for (const key of RECORD_FILE_KEYS) {
+      const record = node[key];
+      if (record) {
+        const line = serializeRouteFileRecord(key, record, nextIndent);
+        if (line) parts.push(line);
+      }
+    }
+
+    // Children
+    if (node.children.length > 0) {
+      const childNodes = node.children.map((c) => serializeNode(c, nextIndent));
+      parts.push(`${nextIndent}children: [\n${childNodes.join(',\n')}\n${nextIndent}],`);
+    } else {
+      parts.push(`${nextIndent}children: [],`);
+    }
+
+    // Parallel slots
+    const slotKeys = Object.keys(node.slots);
+    if (slotKeys.length > 0) {
+      const slotEntries: string[] = [];
+      for (const slotName of slotKeys) {
+        const slotNode = node.slots[slotName]!;
+        slotEntries.push(
+          `${nextIndent}    ${JSON.stringify(slotName)}: ${serializeNode(slotNode, nextIndent + '  ')}`
+        );
+      }
+      parts.push(`${nextIndent}slots: {\n${slotEntries.join(',\n')}\n${nextIndent}},`);
+    } else {
+      parts.push(`${nextIndent}slots: {},`);
+    }
+
+    return `${indent}{\n${parts.join('\n')}\n${indent}}`;
+  }
+
+  const rootSerialized = serializeNode(tree.root, '  ');
+
+  let proxyLine = '';
+  if (tree.proxy) {
+    const v = addImport(tree.proxy);
+    proxyLine = `  proxy: { load: ${v}, filePath: ${JSON.stringify(tree.proxy.filePath)} },`;
+  }
+
+  let globalErrorLine = '';
+  if (tree.globalError) {
+    const v = addImport(tree.globalError);
+    globalErrorLine = `  globalError: { load: ${v}, filePath: ${JSON.stringify(tree.globalError.filePath)} },`;
+  }
+
+  // Serialize the rewrite objects wholesale — an explicit field list here
+  // silently drops any field added to InterceptionRewrite, and the guard that
+  // reads it would then fall back to matching too broadly. InterceptionRewrite
+  // is plain JSON data by construction (no file references, no functions).
+  const rewrites = collectInterceptionRewrites(tree.root);
+  const rewritesLine =
+    rewrites.length > 0 ? `  interceptionRewrites: ${JSON.stringify(rewrites)},` : '';
+
+  const code = [
+    '// Auto-generated route manifest — do not edit.',
+    '// Generated by timber-routing plugin.',
+    '',
+    ...imports,
+    '',
+    'const manifest = {',
+    `  viteRoot: ${JSON.stringify(viteRoot)},`,
+    proxyLine,
+    globalErrorLine,
+    rewritesLine,
+    `  root: ${rootSerialized},`,
+    '};',
+    '',
+    'export default manifest;',
+  ]
+    .filter((line) => line !== undefined && line !== '')
+    .join('\n');
+
+  return code;
+}
+
+// ── Schema module ───────────────────────────────────────────────────────
+
+/**
+ * Generate the virtual:timber-schema module.
+ *
+ * When app/schema.{ts,tsx,js,jsx} exists, generates a module that
+ * imports the schema and resolves its segmentParams codecs into a
+ * bare-name codec map for runtime coercion.
+ */
+export function generateSchemaModule(appDir: string): string {
+  let schemaPath: string | null = null;
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const candidate = join(appDir, `schema${ext}`);
+    if (existsSync(candidate)) {
+      schemaPath = candidate;
+      break;
+    }
+  }
+
+  if (!schemaPath) {
+    return [
+      '// Auto-generated schema loader — no app/schema.ts found.',
+      'export default null;',
+    ].join('\n');
+  }
+
+  return [
+    '// Auto-generated schema loader — do not edit.',
+    '// Generated by timber-routing plugin (TIM-931).',
+    '',
+    `import schema from ${JSON.stringify(schemaPath)};`,
+    `import { resolveSchemaCodecs } from '@timber-js/app/params';`,
+    '',
+    'const globalCodecs = schema?.segmentParams',
+    '  ? resolveSchemaCodecs(schema.segmentParams)',
+    '  : null;',
+    '',
+    'export default globalCodecs;',
+  ].join('\n');
+}