@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/tests/router/rscPayloadRouterMatrix.test.ts

@@ -0,0 +1,197 @@
+import {
+  __setTanstackRscPayloadDecoderForTests,
+  createTanstackRscServerPayload,
+  handleTanstackRscRedirect,
+  loadTanstackRscRouteData,
+} from '../../src/runtime/rsc/payloadRouter';
+
+function createPayload(
+  routeId: string,
+  loaderData: unknown,
+  options: { errors?: Record<string, unknown> | null } = {},
+) {
+  return {
+    type: 'render',
+    actionData: null,
+    errors: options.errors ?? null,
+    loaderData: loaderData === undefined ? {} : { [routeId]: loaderData },
+    location: { href: routeId },
+    routes: [{ id: routeId, hasLoader: true }],
+  };
+}
+
+async function decodeJsonPayload(stream: ReadableStream<Uint8Array>) {
+  return JSON.parse(await new Response(stream).text());
+}
+
+describe('tanstack rsc payload router matrix', () => {
+  afterEach(() => {
+    __setTanstackRscPayloadDecoderForTests();
+    rstest.restoreAllMocks();
+  });
+
+  test('normalizes redirect basenames while preserving status and non-location headers', () => {
+    const scenarios = [
+      {
+        location: '/base',
+        name: 'exact basename',
+        redirect: '/',
+      },
+      {
+        location: '/base/login?from=%2Fbase',
+        name: 'leading basename',
+        redirect: '/login?from=%2Fbase',
+      },
+      {
+        location: '/shop/base/login',
+        name: 'mid-path basename',
+        redirect: '/shop/base/login',
+      },
+    ] as const;
+
+    for (const scenario of scenarios) {
+      const response = handleTanstackRscRedirect(
+        new Headers({
+          Location: scenario.location,
+          'X-Trace': scenario.name,
+        }),
+        '/base',
+        307,
+      );
+
+      expect(response.status).toBe(307);
+      expect(response.headers.get('Location')).toBeNull();
+      expect(response.headers.get('X-Modernjs-BaseUrl')).toBe('/base');
+      expect(response.headers.get('X-Modernjs-Redirect')).toBe(
+        scenario.redirect,
+      );
+      expect(response.headers.get('X-Trace')).toBe(scenario.name);
+    }
+  });
+
+  test('separates payload fetch cache entries by URL and request method', async () => {
+    const payloads = [
+      createPayload('/resource', { method: 'GET' }),
+      createPayload('/resource', { method: 'POST' }),
+    ];
+    let payloadIndex = 0;
+    const fetchMock = rstest.fn(() =>
+      Promise.resolve(new Response(JSON.stringify(payloads[payloadIndex++]))),
+    );
+    rstest.stubGlobal('fetch', fetchMock);
+    __setTanstackRscPayloadDecoderForTests(decodeJsonPayload);
+
+    const [getData, postData] = await Promise.all([
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'get' }),
+        request: new Request('http://localhost/resource', { method: 'GET' }),
+        routeId: '/resource',
+      }),
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'post' }),
+        request: new Request('http://localhost/resource', { method: 'POST' }),
+        routeId: '/resource',
+      }),
+    ]);
+
+    expect(getData).toEqual({ method: 'GET' });
+    expect(postData).toEqual({ method: 'POST' });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(fetchMock.mock.calls.map(call => call[0])).toEqual([
+      'http://localhost/resource',
+      'http://localhost/resource',
+    ]);
+  });
+
+  test('rethrows matched route errors from the decoded payload', async () => {
+    const routeError = new Error('route loader failed');
+    const payload = createPayload('/broken', undefined, {
+      errors: { '/broken': routeError },
+    });
+    rstest.stubGlobal(
+      'fetch',
+      rstest.fn(() => Promise.resolve(new Response('payload'))),
+    );
+    __setTanstackRscPayloadDecoderForTests(async () => payload);
+
+    await expect(
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: true }),
+        request: new Request('http://localhost/broken'),
+        routeId: '/broken',
+      }),
+    ).rejects.toBe(routeError);
+  });
+
+  test('returns undefined for route ids missing from the decoded payload', async () => {
+    const loadClientData = rstest.fn(async () => ({ fallback: true }));
+    const payload = createPayload('/known', { known: true });
+    rstest.stubGlobal(
+      'fetch',
+      rstest.fn(() => Promise.resolve(new Response('payload'))),
+    );
+    __setTanstackRscPayloadDecoderForTests(async () => payload);
+
+    await expect(
+      loadTanstackRscRouteData({
+        loadClientData,
+        request: new Request('http://localhost/missing'),
+        routeId: '/missing',
+      }),
+    ).resolves.toBeUndefined();
+    expect(loadClientData).not.toHaveBeenCalled();
+  });
+
+  test('omits server payload matches with no route identity', () => {
+    const payload = createTanstackRscServerPayload({
+      state: {
+        location: { href: '/kept' },
+        matches: [
+          {
+            loaderData: { omitted: true },
+            params: {},
+            pathname: '/missing-id',
+            pathnameBase: '/missing-id',
+            route: {
+              options: {
+                path: 'missing-id',
+                staticData: { modernRouteHasLoader: true },
+              },
+            },
+          },
+          {
+            loaderData: { kept: true },
+            params: {},
+            pathname: '/kept',
+            pathnameBase: '/kept',
+            route: {
+              id: '/kept',
+              options: {
+                path: 'kept',
+                staticData: { modernRouteHasLoader: true },
+              },
+            },
+          },
+        ],
+      },
+    });
+
+    expect(payload.loaderData).toEqual({ '/kept': { kept: true } });
+    expect(payload.routes).toEqual([
+      {
+        handle: undefined,
+        hasAction: false,
+        hasClientLoader: false,
+        hasErrorBoundary: false,
+        hasLoader: true,
+        id: '/kept',
+        index: undefined,
+        params: {},
+        parentId: undefined,
+        path: 'kept',
+        pathname: '/kept',
+        pathnameBase: '/kept',
+      },
+    ]);
+  });
+});

package/tests/router/slotUsageSanitizer.test.ts

@@ -0,0 +1,23 @@
+import { sanitizeSlotArgs } from '../../src/runtime/rsc/slotUsageSanitizer';
+
+describe('RSC slot usage sanitizer', () => {
+  test('redacts callable slot args without serializing function source', () => {
+    function tokenFactory() {
+      return 'token-secret';
+    }
+
+    const args = sanitizeSlotArgs([
+      tokenFactory,
+      { nested: tokenFactory },
+      [tokenFactory],
+    ]);
+
+    expect(args).toEqual([
+      '[Function]',
+      { nested: '[Function]' },
+      ['[Function]'],
+    ]);
+    expect(JSON.stringify(args)).not.toContain('token-secret');
+    expect(JSON.stringify(args)).not.toContain('tokenFactory');
+  });
+});

package/tests/router/ssrPreload.test.ts

@@ -0,0 +1,30 @@
+import { preloadMatchedRouteComponents } from '../../src/runtime/ssrPreload';
+
+describe('preloadMatchedRouteComponents', () => {
+  test('preloads each component identity once per SSR pass', async () => {
+    const sharedComponent = Object.assign(() => null, {
+      preload: rstest.fn(),
+    });
+
+    await preloadMatchedRouteComponents({
+      routesById: {
+        child: {
+          options: {
+            component: sharedComponent,
+          },
+        },
+        root: {
+          options: {
+            component: sharedComponent,
+            pendingComponent: sharedComponent,
+          },
+        },
+      },
+      state: {
+        matches: [{ routeId: 'root' }, { routeId: 'child' }],
+      },
+    } as never);
+
+    expect(sharedComponent.preload).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/router/tanstackTypes.test.ts

@@ -1,19 +1,172 @@
 import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { isRedirect } from '@tanstack/react-router';
+
+const resolverDelays = new Map<string, number>();
+
+rstest.mock('../../src/cli/tanstackTypes/shared', () => {
+  const actual = rstest.requireActual(
+    '../../src/cli/tanstackTypes/shared',
+  ) as typeof import('../../src/cli/tanstackTypes/shared');
+
+  return {
+    ...actual,
+    resolveFileNoExt: async (inputNoExtPath: string) => {
+      const normalized = inputNoExtPath.replaceAll('\\', '/');
+      const delay =
+        [...resolverDelays.entries()].find(([suffix]) =>
+          normalized.endsWith(suffix),
+        )?.[1] ?? 0;
+
+      if (delay > 0) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+
+      return actual.resolveFileNoExt(inputNoExtPath);
+    },
+  };
+});
+
 import {
   collectCanonicalRoutesForEntry,
   generateTanstackRouterTypesSourceForEntry,
 } from '../../src/cli/tanstackTypes';
+import { throwTanstackRedirect } from '../../src/runtime/loaderBridge';
 
 const execFileAsync = promisify(execFile);
+const routerGenGoldenPath = path.join(
+  __dirname,
+  'fixtures',
+  'router-gen.golden.txt',
+);
+const routerGenOxlintConfigPath = path.join(
+  __dirname,
+  'fixtures',
+  'router-gen.oxlint.json',
+);
+const oxlintCliPath = path.resolve(
+  __dirname,
+  '../../../../toolkit/code-tools/node_modules/oxlint/bin/oxlint',
+);
+
+type RedirectLike = {
+  options?: {
+    href?: string;
+    to?: string;
+  };
+};
+
+function catchThrown(fn: () => unknown): unknown {
+  try {
+    fn();
+  } catch (err) {
+    return err;
+  }
+  throw new Error('expected function to throw');
+}
+
+function extractRouteGenerationOrder(source: string) {
+  return source.split('\n').filter(line => {
+    return (
+      line.startsWith('import component_') ||
+      line.startsWith('const route_') ||
+      line.includes('component: component_') ||
+      line.startsWith('export const routeTree')
+    );
+  });
+}
+
+async function writeGoldenRouterFixture(srcDirectory: string) {
+  const files = new Map([
+    [
+      'routes/(app)/layout.tsx',
+      'export default function AppLayout() { return null; }',
+    ],
+    [
+      'routes/(app)/users/(userId)/page.tsx',
+      'export default function UserPage() { return null; }',
+    ],
+    [
+      'routes/(app)/users/(userId)/page.data.ts',
+      [
+        'export const loader = () => ({ userId: "42" });',
+        'export const action = () => Response.json({ ok: true });',
+      ].join('\n'),
+    ],
+    [
+      'routes/(app)/docs/splat.tsx',
+      'export default function DocsSplatPage() { return null; }',
+    ],
+    [
+      'routes/search.contract.ts',
+      [
+        'export const validateSearch = (search: { tab?: string }) => ({ tab: search.tab ?? "overview" });',
+        'export const loaderDeps = ({ search }: { search: { tab: string } }) => ({ tab: search.tab });',
+      ].join('\n'),
+    ],
+  ]);
+
+  for (const [relativePath, contents] of files) {
+    const filePath = path.join(srcDirectory, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, contents);
+  }
+}
+
+async function generateGoldenRouterGen(srcDirectory: string) {
+  await writeGoldenRouterFixture(srcDirectory);
+
+  const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+    appContext: {
+      srcDirectory,
+      internalSrcAlias: '@/_',
+    } as any,
+    entryName: 'golden',
+    routes: [
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(app)/layout',
+            _component: '@/_/routes/(app)/layout',
+            children: [
+              {
+                type: 'nested',
+                id: '(app)/users/(userId)/page',
+                path: 'users/:userId',
+                _component: '@/_/routes/(app)/users/(userId)/page',
+                data: '@/_/routes/(app)/users/(userId)/page.data',
+                action: '@/_/routes/(app)/users/(userId)/page.data',
+                validateSearch: '@/_/routes/search.contract',
+                loaderDeps: '@/_/routes/search.contract',
+              },
+              {
+                type: 'nested',
+                id: '(app)/docs/splat/page',
+                path: 'docs/*',
+                _component: '@/_/routes/(app)/docs/splat',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any,
+  });
+
+  return routerGenTs;
+}
 
 describe('tanstack router type generation', () => {
   let tempDir: string | undefined;
 
   afterEach(async () => {
+    resolverDelays.clear();
     if (tempDir) {
       await rm(tempDir, { recursive: true, force: true });
       tempDir = undefined;
@@ -77,6 +230,15 @@ describe('tanstack router type generation', () => {
     expect(routerGenTs).not.toContain('function modernLoaderToTanstack');
     expect(routerGenTs).not.toContain('function createRouteStaticData');
     expect(routerGenTs).not.toContain('function throwTanstackRedirect');
+    expect(routerGenTs).not.toContain('new URL(target)');
+    expect(routerGenTs).not.toContain('redirect({ to: target })');
+
+    const redirectError = catchThrown(() =>
+      throwTanstackRedirect('https://example.com/absolute'),
+    ) as RedirectLike;
+    expect(isRedirect(redirectError)).toBe(true);
+    expect(redirectError.options?.href).toBe('https://example.com/absolute');
+    expect(redirectError.options?.to).toBeUndefined();
   });
 
   test('emits resolvable relative component imports for routes carrying _component', async () => {
@@ -167,6 +329,141 @@ describe('tanstack router type generation', () => {
     expect(dataOnlyRoute).not.toContain('component:');
   });
 
+  test('keeps generated source stable when route module resolution races', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
+    const srcDirectory = path.join(tempDir, 'src');
+
+    for (const componentFile of [
+      'routes/slow-page.tsx',
+      'routes/fast-page.tsx',
+      'routes/shared-page.tsx',
+    ]) {
+      const componentPath = path.join(srcDirectory, componentFile);
+      await mkdir(path.dirname(componentPath), { recursive: true });
+      await writeFile(
+        componentPath,
+        'export default function Page() { return null; }',
+      );
+    }
+
+    const routes = [
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: 'slow/page',
+            path: 'slow',
+            _component: '@/_/routes/slow-page',
+          },
+          {
+            type: 'nested',
+            id: 'fast/page',
+            path: 'fast',
+            _component: '@/_/routes/fast-page',
+          },
+          {
+            type: 'nested',
+            id: 'shared-a/page',
+            path: 'shared-a',
+            _component: '@/_/routes/shared-page',
+          },
+          {
+            type: 'nested',
+            id: 'shared-b/page',
+            path: 'shared-b',
+            _component: '@/_/routes/shared-page',
+          },
+        ],
+      },
+    ] as any;
+
+    const generateWithResolverDelays = async (
+      delays: Record<string, number>,
+    ) => {
+      resolverDelays.clear();
+      for (const [suffix, delay] of Object.entries(delays)) {
+        resolverDelays.set(suffix, delay);
+      }
+
+      const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+        appContext: {
+          srcDirectory,
+          internalSrcAlias: '@/_',
+        } as any,
+        entryName: 'index',
+        routes,
+      });
+
+      return routerGenTs;
+    };
+
+    const sequentialOutput = await generateWithResolverDelays({});
+    const racedOutput = await generateWithResolverDelays({
+      '/routes/slow-page': 25,
+    });
+
+    expect(
+      racedOutput.match(/from "\.\.\/\.\.\/routes\/shared-page";/g),
+    ).toHaveLength(1);
+    expect(extractRouteGenerationOrder(racedOutput)).toEqual(
+      extractRouteGenerationOrder(sequentialOutput),
+    );
+    expect(racedOutput).toBe(sequentialOutput);
+  });
+
+  test('matches checked-in router.gen golden output', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
+    const srcDirectory = path.join(tempDir, 'src');
+    const routerGenTs = await generateGoldenRouterGen(srcDirectory);
+
+    if (process.env.UPDATE_TANSTACK_ROUTER_GOLDEN === '1') {
+      await mkdir(path.dirname(routerGenGoldenPath), { recursive: true });
+      await writeFile(routerGenGoldenPath, routerGenTs);
+    }
+
+    await expect(readFile(routerGenGoldenPath, 'utf8')).resolves.toBe(
+      routerGenTs,
+    );
+  });
+
+  test('emits suppression-free router source that passes the generated-artifact lint fixture', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
+    const srcDirectory = path.join(tempDir, 'src');
+    const routerGenTs = await generateGoldenRouterGen(srcDirectory);
+    const routerGenPath = path.join(
+      srcDirectory,
+      'modern-tanstack',
+      'golden',
+      'router.gen.ts',
+    );
+
+    await mkdir(path.dirname(routerGenPath), { recursive: true });
+    await writeFile(routerGenPath, routerGenTs);
+
+    expect(routerGenTs).not.toContain('eslint-disable');
+
+    const { stderr, stdout } = await execFileAsync(
+      process.execPath,
+      [
+        oxlintCliPath,
+        routerGenPath,
+        '--config',
+        routerGenOxlintConfigPath,
+        '--no-ignore',
+        '--report-unused-disable-directives-severity',
+        'error',
+        '--format',
+        'unix',
+      ],
+      { cwd: tempDir },
+    );
+
+    expect(`${stdout}${stderr}`).toBe('');
+  });
+
   test('typechecks generated TanStack search contracts', async () => {
     tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
     const srcDirectory = path.join(tempDir, 'src');

package/dist/esm/runtime/pluginCore.mjs

@@ -1,14 +0,0 @@
-import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
-import { merge } from "@modern-js/runtime-utils/merge";
-function getMergedRouterConfig(api, userConfig) {
-    const pluginConfig = api.getRuntimeConfig();
-    return merge(pluginConfig.router || {}, userConfig);
-}
-function getFinalRouteConfig(mergedConfig) {
-    return {
-        routes: getGlobalRoutes(),
-        globalApp: getGlobalLayoutApp(),
-        ...mergedConfig.routesConfig
-    };
-}
-export { getFinalRouteConfig, getMergedRouterConfig };

package/dist/esm-node/runtime/pluginCore.mjs

@@ -1,15 +0,0 @@
-import "node:module";
-import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
-import { merge } from "@modern-js/runtime-utils/merge";
-function getMergedRouterConfig(api, userConfig) {
-    const pluginConfig = api.getRuntimeConfig();
-    return merge(pluginConfig.router || {}, userConfig);
-}
-function getFinalRouteConfig(mergedConfig) {
-    return {
-        routes: getGlobalRoutes(),
-        globalApp: getGlobalLayoutApp(),
-        ...mergedConfig.routesConfig
-    };
-}
-export { getFinalRouteConfig, getMergedRouterConfig };

package/dist/types/runtime/pluginCore.d.ts

@@ -1,21 +0,0 @@
-import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
-import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
-import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
-import type { RouterExtendsHooks } from './hooks';
-import type { RouterConfig } from './types';
-export type TanstackRouterRuntimeConfig = {
-    plugins?: TanstackRouterRuntimePlugin[];
-    router?: Partial<RouterConfig>;
-    [key: string]: unknown;
-};
-type TanstackRouterRuntimeExtends = Required<RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>> & {
-    extendHooks: RouterExtendsHooks;
-};
-export type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
-export type TanstackRouterRuntimePlugin = Plugin<TanstackRouterPluginAPI, TInternalRuntimeContext>;
-export declare function getMergedRouterConfig(api: TanstackRouterPluginAPI, userConfig: Partial<RouterConfig>): RouterConfig;
-export declare function getFinalRouteConfig(mergedConfig: RouterConfig): {
-    routes: (import("@modern-js/types").NestedRoute<string | (() => JSX.Element)> | import("@modern-js/types").PageRoute)[] | undefined;
-    globalApp: import("react").ComponentClass<{}, any> | import("react").FunctionComponent<{}> | undefined;
-};
-export {};

package/src/runtime/pluginCore.ts

@@ -1,48 +0,0 @@
-import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
-import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
-import {
-  getGlobalLayoutApp,
-  getGlobalRoutes,
-  type TInternalRuntimeContext,
-} from '@modern-js/runtime/context';
-import { merge } from '@modern-js/runtime-utils/merge';
-import type { RouterExtendsHooks } from './hooks';
-import type { RouterConfig } from './types';
-
-export type TanstackRouterRuntimeConfig = {
-  plugins?: TanstackRouterRuntimePlugin[];
-  router?: Partial<RouterConfig>;
-  [key: string]: unknown;
-};
-
-type TanstackRouterRuntimeExtends = Required<
-  RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>
-> & {
-  extendHooks: RouterExtendsHooks;
-};
-
-export type TanstackRouterPluginAPI =
-  RuntimePluginAPI<TanstackRouterRuntimeExtends>;
-
-export type TanstackRouterRuntimePlugin = Plugin<
-  TanstackRouterPluginAPI,
-  TInternalRuntimeContext
->;
-
-export function getMergedRouterConfig(
-  api: TanstackRouterPluginAPI,
-  userConfig: Partial<RouterConfig>,
-): RouterConfig {
-  const pluginConfig = api.getRuntimeConfig() as {
-    router?: Partial<RouterConfig>;
-  };
-  return merge(pluginConfig.router || {}, userConfig) as RouterConfig;
-}
-
-export function getFinalRouteConfig(mergedConfig: RouterConfig) {
-  return {
-    routes: getGlobalRoutes(),
-    globalApp: getGlobalLayoutApp(),
-    ...mergedConfig.routesConfig,
-  };
-}