@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

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/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);
+  });
+});