fix(platform): recognize dynamic redirects in route diagnostics

The dev-time route idiom analyzer only treated a plain string or an
expression-free template literal as a redirect, so a page whose
`routeMeta.redirectTo` is a function, an identifier or an interpolated
template was reported as `missing-default-export` even though the
router builds a redirect route for it. It also skipped a `routeMeta`
wrapped in `satisfies`, `as`, a type assertion or parentheses.

A `redirectTo` property now counts as a redirect unless its value is
`null` or `undefined`, which mirrors the runtime. The analyzer unwraps
the wrapper expressions before reading the object, keeps the
relative-target check for the static part of the target, and reports a
component export beside a function redirect as it does beside a string.

Closes #2709

Author: byrondover

packages/platform/src/lib/route-idiom-diagnostics.spec.ts

@@ -81,6 +81,159 @@ describe('route-idiom-diagnostics', () => {
     );
   });
 
+  it('does not warn about missing default exports for function redirects', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/users/[userId]/index.page.ts',
+      code: [
+        'export const routeMeta = {',
+        "  redirectTo: ({ params }) => `/users/${params['userId']}/profile`,",
+        "  pathMatch: 'full',",
+        '};',
+      ].join('\n'),
+    });
+
+    expect(diagnostics.map((diagnostic) => diagnostic.code)).not.toContain(
+      'missing-default-export',
+    );
+  });
+
+  it('does not warn about missing default exports for identifier redirects', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/index.page.ts',
+      code: [
+        "const redirect = () => '/';",
+        '',
+        'export const routeMeta = {',
+        '  redirectTo: redirect,',
+        "  pathMatch: 'full',",
+        '};',
+      ].join('\n'),
+    });
+
+    expect(diagnostics.map((diagnostic) => diagnostic.code)).not.toContain(
+      'missing-default-export',
+    );
+  });
+
+  it('treats an absolute template redirect as a redirect-only route', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/index.page.ts',
+      code: [
+        "const id = 'me';",
+        '',
+        'export const routeMeta = {',
+        '  redirectTo: `/users/${id}`,',
+        "  pathMatch: 'full',",
+        '};',
+      ].join('\n'),
+    });
+
+    const codes = diagnostics.map((diagnostic) => diagnostic.code);
+
+    expect(codes).not.toContain('missing-default-export');
+    expect(codes).not.toContain('relative-redirect');
+  });
+
+  it('warns on relative template redirect targets', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/cities/index.page.ts',
+      code: [
+        "const id = 'new-york';",
+        '',
+        'export const routeMeta = {',
+        '  redirectTo: `cities/${id}`,',
+        "  pathMatch: 'full',",
+        '};',
+      ].join('\n'),
+    });
+
+    expect(diagnostics.map((diagnostic) => diagnostic.code)).toContain(
+      'relative-redirect',
+    );
+  });
+
+  it('does not warn on template redirect targets without a static prefix', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/index.page.ts',
+      code: [
+        "const prefix = '/account';",
+        '',
+        'export const routeMeta = {',
+        '  redirectTo: `${prefix}/settings`,',
+        "  pathMatch: 'full',",
+        '};',
+      ].join('\n'),
+    });
+
+    const codes = diagnostics.map((diagnostic) => diagnostic.code);
+
+    expect(codes).not.toContain('missing-default-export');
+    expect(codes).not.toContain('relative-redirect');
+  });
+
+  it.each([
+    ['satisfies', 'export const routeMeta = {', '} satisfies RouteMeta;'],
+    ['as', 'export const routeMeta = {', '} as RouteMeta;'],
+    ['a type assertion', 'export const routeMeta = <RouteMeta>{', '};'],
+    ['parentheses', 'export const routeMeta = ({', '});'],
+  ])(
+    'does not warn about missing default exports for valid redirect-only routes wrapped in %s',
+    (_wrapper, open, close) => {
+      const diagnostics = analyzeAnalogRouteFile({
+        filename: '/workspace/src/app/pages/index.page.ts',
+        code: [
+          "import type { RouteMeta } from '@analogjs/router';",
+          '',
+          open,
+          "  redirectTo: '/home',",
+          "  pathMatch: 'full',",
+          close,
+        ].join('\n'),
+      });
+
+      expect(diagnostics.map((diagnostic) => diagnostic.code)).not.toContain(
+        'missing-default-export',
+      );
+    },
+  );
+
+  it.each(['null', 'undefined', 'null as any'])(
+    'warns about missing default exports when redirectTo is %s',
+    (value) => {
+      const diagnostics = analyzeAnalogRouteFile({
+        filename: '/workspace/src/app/pages/index.page.ts',
+        code: [
+          'export const routeMeta = {',
+          `  redirectTo: ${value},`,
+          "  pathMatch: 'full',",
+          '};',
+        ].join('\n'),
+      });
+
+      expect(diagnostics.map((diagnostic) => diagnostic.code)).toContain(
+        'missing-default-export',
+      );
+    },
+  );
+
+  it('warns when function redirect routes also default-export a component', () => {
+    const diagnostics = analyzeAnalogRouteFile({
+      filename: '/workspace/src/app/pages/index.page.ts',
+      code: [
+        'export const routeMeta = {',
+        "  redirectTo: () => '/home',",
+        "  pathMatch: 'full',",
+        '};',
+        '',
+        'export default class HomeRedirectPage {}',
+      ].join('\n'),
+    });
+
+    expect(diagnostics.map((diagnostic) => diagnostic.code)).toContain(
+      'redirect-with-component',
+    );
+  });
+
   it('warns when a layout-looking route does not reference RouterOutlet', () => {
     const diagnostics = analyzeAnalogRouteFile({
       filename: '/workspace/src/app/pages/products.page.ts',

packages/platform/src/lib/route-idiom-diagnostics.ts

@@ -18,6 +18,14 @@ export interface AnalyzeAnalogRouteFileOptions {
 const PAGE_FILE_RE = /\.page\.ts$/;
 const ROUTER_OUTLET_RE = /\bRouterOutlet\b|<router-outlet(?:\s|>)/;
 
+// Valid AST node types: grouping parentheses, as, satisfies, angle-bracket type assertion
+const WRAPPER_EXPRESSIONS = new Set([
+  'ParenthesizedExpression',
+  'TSAsExpression',
+  'TSSatisfiesExpression',
+  'TSTypeAssertion',
+]);
+
 export function analyzeAnalogRouteFile(
   options: AnalyzeAnalogRouteFileOptions,
 ): AnalogRouteIdiomDiagnostic[] {
@@ -69,9 +77,8 @@ export function analyzeAnalogRouteFile(
   }
 
   if (
-    routeMetaInfo?.hasRedirect &&
-    routeMetaInfo.redirectTo &&
-    !routeMetaInfo.redirectTo.startsWith('/')
+    routeMetaInfo?.redirectTarget &&
+    !routeMetaInfo.redirectTarget.startsWith('/')
   ) {
     diagnostics.push({
       code: 'relative-redirect',
@@ -158,32 +165,42 @@ function getRouteMetaInfo(
   bindingName: string,
 ): {
   hasRedirect: boolean;
-  redirectTo?: string;
+  redirectTarget?: string;
 } | null {
-  const routeMetaNode = getExportedBindingInitializer(program, bindingName);
+  const routeMetaNode = unwrapExpression(
+    getExportedBindingInitializer(program, bindingName),
+  );
 
   if (routeMetaNode?.type !== 'ObjectExpression') {
     return null;
   }
 
-  let redirectTo: string | undefined;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let redirectTo: any;
 
   for (const property of routeMetaNode.properties ?? []) {
     if (property?.type !== 'Property') {
       continue;
     }
 
     const keyName = getPropertyName(property.key);
+
     if (keyName !== 'redirectTo') {
       continue;
     }
 
-    redirectTo = getStringValue(property.value);
+    redirectTo = property.value;
+  }
+
+  const value = unwrapExpression(redirectTo);
+
+  if (!value || isNullish(value)) {
+    return { hasRedirect: false };
   }
 
   return {
-    hasRedirect: typeof redirectTo === 'string' && redirectTo.length > 0,
-    redirectTo,
+    hasRedirect: true,
+    redirectTarget: getStaticRedirectTarget(value),
   };
 }
 
@@ -312,24 +329,44 @@ function getPropertyName(
   return undefined;
 }
 
-function getStringValue(
+function getStaticRedirectTarget(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   node: any,
 ): string | undefined {
   if (
-    (node?.type === 'Literal' || node?.type === 'StringLiteral') &&
+    (node.type === 'Literal' || node.type === 'StringLiteral') &&
     typeof node.value === 'string'
   ) {
     return node.value;
   }
 
-  if (
-    node?.type === 'TemplateLiteral' &&
-    node.expressions?.length === 0 &&
-    node.quasis?.length === 1
-  ) {
-    return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+  if (node.type === 'TemplateLiteral') {
+    const lead = node.quasis?.[0]?.value.cooked ?? node.quasis?.[0]?.value.raw;
+    return lead || undefined;
   }
 
   return undefined;
 }
+
+function isNullish(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  node: any,
+): boolean {
+  return (
+    (node.type === 'Literal' && node.value === null) ||
+    (node.type === 'Identifier' && node.name === 'undefined') ||
+    (node.type === 'UnaryExpression' && node.operator === 'void')
+  );
+}
+
+function unwrapExpression(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  node: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): any | undefined {
+  while (node && WRAPPER_EXPRESSIONS.has(node.type)) {
+    node = node.expression;
+  }
+
+  return node;
+}