@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/tests/router/rsc.test.tsx

@@ -2,6 +2,10 @@ import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from '@modern-js/runtim
 import type React from 'react';
 import { isValidElement } from 'react';
 import { createRscProxy } from '../../src/runtime/rsc/createRscProxy';
+import {
+  reviveTanstackRscFlightValues,
+  serializeTanstackRscFlightValues,
+} from '../../src/runtime/rsc/flightSerialization';
 import {
   __setTanstackRscPayloadDecoderForTests,
   createTanstackRscServerPayload,
@@ -65,6 +69,54 @@ describe('tanstack rsc runtime helpers', () => {
     ]);
   });
 
+  test('revives shared structures that the Flight serializer preserves', async () => {
+    const shared = { label: 'shared' };
+    const serialized = serializeTanstackRscFlightValues({
+      left: shared,
+      right: shared,
+    }) as { left: unknown; right: unknown };
+
+    const revived = (await reviveTanstackRscFlightValues(serialized)) as {
+      left: unknown;
+      right: unknown;
+    };
+
+    expect(serialized.left).toBe(serialized.right);
+    expect(revived.left).toBe(revived.right);
+  });
+
+  test('serializes TanStack RSC flight values nested in map and set containers', () => {
+    const stream: ServerComponentStream = {
+      createReplayStream: () => new ReadableStream<Uint8Array>(),
+    };
+    const proxy = createRscProxy(() => null, {
+      renderable: true,
+      stream,
+    }) as React.ReactElement & Record<PropertyKey, unknown>;
+
+    const serialized = serializeTanstackRscFlightValues({
+      map: new Map([['slot', proxy]]),
+      set: new Set([proxy]),
+    }) as {
+      map: Map<string, Record<string, unknown>>;
+      set: Set<Record<string, unknown>>;
+    };
+
+    const mapValue = serialized.map.get('slot');
+    const [setValue] = serialized.set;
+
+    expect(mapValue).not.toBe(proxy);
+    expect(setValue).not.toBe(proxy);
+    expect(mapValue).toMatchObject({
+      __modernTanstackRsc: true,
+      kind: 'renderable',
+    });
+    expect(setValue).toMatchObject({
+      __modernTanstackRsc: true,
+      kind: 'renderable',
+    });
+  });
+
   test('renderable RSC proxies preserve React element behavior and metadata', () => {
     const stream: ServerComponentStream = {
       createReplayStream: () => new ReadableStream<Uint8Array>(),
@@ -219,6 +271,36 @@ describe('tanstack rsc runtime helpers', () => {
     expect(JSON.stringify(payload.errors)).not.toContain('stack secret');
   });
 
+  test('redacts production TanStack RSC non-Error server payload errors', () => {
+    const payload = withNodeEnv('production', () =>
+      createTanstackRscServerPayload({
+        state: {
+          location: { href: '/plain' },
+          matches: [
+            {
+              error: { message: 'plain secret', token: 'token secret' },
+              params: {},
+              pathname: '/plain',
+              pathnameBase: '/plain',
+              route: { id: '/plain' },
+              routeId: '/plain',
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(payload.errors).toMatchObject({
+      '/plain': {
+        message: 'Unexpected Server Error',
+        stack: undefined,
+        __type: 'Error',
+      },
+    });
+    expect(JSON.stringify(payload.errors)).not.toContain('plain secret');
+    expect(JSON.stringify(payload.errors)).not.toContain('token secret');
+  });
+
   test('converts TanStack RSC redirects to Modern RSC navigation headers', () => {
     const response = handleTanstackRscRedirect(
       new Headers({ Location: '/base/login' }),
@@ -232,6 +314,54 @@ describe('tanstack rsc runtime helpers', () => {
     expect(response.headers.get('X-Modernjs-BaseUrl')).toBe('/base');
   });
 
+  test('preserves TanStack RSC redirect paths that do not start with the basename', () => {
+    const response = handleTanstackRscRedirect(
+      new Headers({ Location: '/shop/base/login' }),
+      '/base',
+      302,
+    );
+
+    expect(response.headers.get('X-Modernjs-Redirect')).toBe(
+      '/shop/base/login',
+    );
+  });
+
+  test('preserves RSC redirect response status and headers in TanStack redirects', async () => {
+    rstest.stubGlobal(
+      'fetch',
+      rstest.fn(() =>
+        Promise.resolve(
+          new Response(null, {
+            headers: {
+              'X-Modernjs-Redirect': '/login',
+              'X-Trace': 'preserved',
+            },
+            status: 308,
+          }),
+        ),
+      ),
+    );
+
+    const thrown = (await loadTanstackRscRouteData({
+      loadClientData: async () => ({ fallback: true }),
+      request: new Request('http://localhost/products'),
+      routeId: '/products',
+    }).then(
+      () => {
+        throw new Error('expected redirect');
+      },
+      err => err,
+    )) as Response & {
+      options?: { statusCode?: number; to?: string };
+    };
+
+    expect(thrown).toBeInstanceOf(Response);
+    expect(thrown.status).toBe(308);
+    expect(thrown.headers.get('X-Trace')).toBe('preserved');
+    expect(thrown.options?.statusCode).toBe(308);
+    expect(thrown.options?.to).toBe('/login');
+  });
+
   test('loads one RSC payload for multiple server route loaders', async () => {
     const payload = {
       type: 'render',
@@ -275,6 +405,65 @@ describe('tanstack rsc runtime helpers', () => {
     expect(decodeMock).toHaveBeenCalledTimes(1);
   });
 
+  test('separates RSC payload cache entries by forwarded request headers', async () => {
+    const payloadByUser: Record<string, unknown> = {
+      alice: {
+        type: 'render',
+        actionData: null,
+        errors: null,
+        loaderData: {
+          '/profile': { user: 'alice' },
+        },
+        location: { href: '/profile' },
+        routes: [{ id: '/profile', hasLoader: true }],
+      },
+      bob: {
+        type: 'render',
+        actionData: null,
+        errors: null,
+        loaderData: {
+          '/profile': { user: 'bob' },
+        },
+        location: { href: '/profile' },
+        routes: [{ id: '/profile', hasLoader: true }],
+      },
+    };
+    const fetchMock = rstest.fn(
+      (_url: string | URL | Request, init?: RequestInit) => {
+        const user =
+          init?.headers instanceof Headers ? init.headers.get('x-user') : null;
+        return Promise.resolve(
+          new Response(JSON.stringify(payloadByUser[user || ''])),
+        );
+      },
+    );
+    rstest.stubGlobal('fetch', fetchMock);
+    __setTanstackRscPayloadDecoderForTests(async stream =>
+      JSON.parse(await new Response(stream).text()),
+    );
+
+    const [aliceData, bobData] = await Promise.all([
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'alice' }),
+        request: new Request('http://localhost/profile', {
+          headers: { 'x-user': 'alice' },
+        }),
+        routeId: '/profile',
+      }),
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'bob' }),
+        request: new Request('http://localhost/profile', {
+          headers: { 'x-user': 'bob' },
+        }),
+        routeId: '/profile',
+      }),
+    ]);
+
+    expect(aliceData).toEqual({ user: 'alice' });
+    expect(bobData).toEqual({ user: 'bob' });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
   test('uses client loader data without requesting an RSC payload for client-loader routes', async () => {
     const fetchMock = rstest.fn();
     const loadClientData = rstest.fn(async () => ({ client: true }));

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,163 @@
 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',
+);
+
+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 +221,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 +320,106 @@ 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('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/src/runtime/pluginCore.ts

@@ -1,56 +0,0 @@
-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 RuntimeInterrupt = (value?: unknown) => unknown;
-
-export type TanstackRouterPluginAPI = {
-  getRuntimeConfig: () => TanstackRouterRuntimeConfig;
-  getHooks: () => RouterExtendsHooks;
-  onBeforeRender: (
-    listener: (
-      context: TInternalRuntimeContext,
-      interrupt: RuntimeInterrupt,
-    ) => unknown,
-  ) => void;
-  wrapRoot: (listener: (App: any) => any) => void;
-  [key: string]: any;
-};
-
-export type TanstackRouterRuntimePlugin = {
-  name?: string;
-  registryHooks?: RouterExtendsHooks;
-  setup?: (api: TanstackRouterPluginAPI) => unknown;
-  [key: string]: unknown;
-};
-
-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,
-): RouterConfig['routesConfig'] {
-  return {
-    routes: getGlobalRoutes() as RouterConfig['routesConfig']['routes'],
-    globalApp: getGlobalLayoutApp(),
-    ...mergedConfig.routesConfig,
-  };
-}