@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/tests/router/routerCompatibility.test.ts

@@ -1,239 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-const REGISTRY_SLOT: unique symbol = Symbol.for(
-  '@modern-js/runtime:router-providers:v3',
-);
-const registryHost = globalThis as { [REGISTRY_SLOT]?: unknown };
-const webpackHost = globalThis as typeof globalThis & {
-  __webpack_require__?: { u: (chunkId: unknown) => string };
-};
-const installWebpackRequire = () => {
-  webpackHost.__webpack_require__ = { u: chunkId => String(chunkId) };
-};
-
-type LegacyRuntimeRouterModule = {
-  getLegacyRouterPluginInvocationCount: () => number;
-  routerPlugin: (...args: unknown[]) => unknown;
-};
-
-type CompatibilityGraph = {
-  factory: (...args: any[]) => any;
-  legacyRuntimeRouter: LegacyRuntimeRouterModule;
-  resolveRouterProvider: (
-    framework?: string,
-  ) => (...args: unknown[]) => unknown;
-  routerPlugin: (...args: any[]) => any;
-};
-
-async function loadCompatibilityGraph(): Promise<CompatibilityGraph> {
-  rstest.resetModules();
-  installWebpackRequire();
-
-  const legacyRuntimeRouter = (await import(
-    '@modern-js/runtime/router/internal'
-  )) as unknown as LegacyRuntimeRouterModule;
-  const { routerPlugin } = await import('../../src/runtime/router');
-  const { tanstackRouterProviderFactory } = await import(
-    '../../src/runtime/register'
-  );
-  const { resolveRouterProvider } = await import('@modern-js/runtime/context');
-
-  return {
-    factory: tanstackRouterProviderFactory,
-    legacyRuntimeRouter,
-    resolveRouterProvider,
-    routerPlugin,
-  };
-}
-
-function resolveTsgoBin(): string {
-  const packageJsonPath = require.resolve(
-    '@typescript/native-preview/package.json',
-  );
-  const packageDirectory = path.dirname(packageJsonPath);
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as {
-    bin?: string | { tsgo?: string };
-  };
-  const binEntry =
-    typeof packageJson.bin === 'string'
-      ? packageJson.bin
-      : packageJson.bin?.tsgo;
-
-  return path.resolve(packageDirectory, binEntry ?? 'bin/tsgo.js');
-}
-
-function runTsgo(tsgoBin: string, configPath: string): void {
-  try {
-    execFileSync(process.execPath, [tsgoBin, '-p', configPath], {
-      stdio: 'pipe',
-    });
-  } catch (error) {
-    const result = error as { stderr?: Buffer; stdout?: Buffer };
-    throw new Error(
-      `TS-Go compatibility check failed:\n${String(result.stdout ?? '')}${String(
-        result.stderr ?? '',
-      )}`,
-    );
-  }
-}
-
-installWebpackRequire();
-
-describe('runtime router compatibility', () => {
-  beforeEach(() => {
-    delete registryHost[REGISTRY_SLOT];
-    rstest.resetModules();
-    installWebpackRequire();
-  });
-
-  afterEach(() => {
-    delete registryHost[REGISTRY_SLOT];
-  });
-
-  it('uses the app-local factory instead of the legacy global wrapper', async () => {
-    const graph = await loadCompatibilityGraph();
-
-    expect('createRouterPlugin' in graph.legacyRuntimeRouter).toBe(false);
-    expect(graph.routerPlugin).toBe(graph.factory);
-    expect(graph.routerPlugin({ framework: 'tanstack' })).toMatchObject({
-      name: '@modern-js/plugin-router-tanstack',
-    });
-    expect(
-      graph.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
-    ).toBe(0);
-  });
-
-  it('keeps independently evaluated legacy module graphs app-local', async () => {
-    const graphA = await loadCompatibilityGraph();
-    const graphB = await loadCompatibilityGraph();
-
-    expect(graphB.factory).not.toBe(graphA.factory);
-    expect(graphB.routerPlugin).toBe(graphB.factory);
-    expect(graphB.resolveRouterProvider('tanstack')).toBe(graphA.factory);
-    expect(graphB.routerPlugin({ framework: 'tanstack' })).toMatchObject({
-      name: '@modern-js/plugin-router-tanstack',
-    });
-    expect(
-      graphA.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
-    ).toBe(0);
-    expect(
-      graphB.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
-    ).toBe(0);
-  });
-
-  it('emits declarations compatible with the oldest runtime router shape', () => {
-    const packageRoot = path.resolve(__dirname, '../..');
-    const sourcePath = path.join(packageRoot, 'src/runtime/router.ts');
-    const legacyFixturePath = path.join(
-      __dirname,
-      'fixtures/legacyRuntimeRouter.ts',
-    );
-    const tempRoot = mkdtempSync(
-      path.join(tmpdir(), 'plugin-tanstack-router-compatibility-'),
-    );
-    const sourceRoot = path.join(tempRoot, 'src');
-    const emittedRoot = path.join(tempRoot, 'types');
-    const tsgoBin = resolveTsgoBin();
-
-    try {
-      mkdirSync(sourceRoot, { recursive: true });
-      writeFileSync(
-        path.join(sourceRoot, 'router.ts'),
-        readFileSync(sourcePath, 'utf8'),
-      );
-      writeFileSync(
-        path.join(sourceRoot, 'register.ts'),
-        [
-          'export declare const tanstackRouterProviderFactory:',
-          '  (userConfig?: Record<string, unknown>) => { name?: string };',
-        ].join('\n'),
-      );
-      writeFileSync(
-        path.join(tempRoot, 'currentRuntimeRouter.d.ts'),
-        [
-          'export type RouterPluginFactory =',
-          '  (userConfig?: Record<string, unknown>) => { name?: string };',
-          'export declare const routerPlugin: RouterPluginFactory;',
-          'export declare const createRouterPlugin:',
-          '  (providers: readonly unknown[]) => RouterPluginFactory;',
-        ].join('\n'),
-      );
-      writeFileSync(
-        path.join(tempRoot, 'emit.json'),
-        JSON.stringify(
-          {
-            compilerOptions: {
-              declaration: true,
-              emitDeclarationOnly: true,
-              module: 'Preserve',
-              moduleResolution: 'Bundler',
-              noCheck: true,
-              outDir: emittedRoot,
-              paths: {
-                '@modern-js/runtime/router/internal': [
-                  './currentRuntimeRouter.d.ts',
-                ],
-              },
-              rootDir: sourceRoot,
-              skipLibCheck: false,
-              strict: true,
-              target: 'ESNext',
-              types: [],
-            },
-            files: [path.join(sourceRoot, 'router.ts')],
-          },
-          null,
-          2,
-        ),
-      );
-
-      runTsgo(tsgoBin, path.join(tempRoot, 'emit.json'));
-
-      const declarationPath = path.join(emittedRoot, 'router.d.ts');
-      writeFileSync(
-        path.join(tempRoot, 'legacyRuntimeRouter.ts'),
-        readFileSync(legacyFixturePath, 'utf8'),
-      );
-      writeFileSync(
-        path.join(tempRoot, 'compatibility.json'),
-        JSON.stringify(
-          {
-            compilerOptions: {
-              module: 'Preserve',
-              moduleResolution: 'Bundler',
-              noEmit: true,
-              paths: {
-                '@modern-js/runtime/router/internal': [
-                  './legacyRuntimeRouter.ts',
-                ],
-              },
-              skipLibCheck: false,
-              strict: true,
-              target: 'ESNext',
-              types: [],
-            },
-            files: [
-              declarationPath,
-              path.join(tempRoot, 'legacyRuntimeRouter.ts'),
-            ],
-          },
-          null,
-          2,
-        ),
-      );
-
-      runTsgo(tsgoBin, path.join(tempRoot, 'compatibility.json'));
-    } finally {
-      rmSync(tempRoot, { force: true, recursive: true });
-    }
-  });
-});

package/tests/router/rscDecoderSecurity.test.ts

@@ -1,113 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-
-type DecoderScenario =
-  | 'action-load'
-  | 'async-iterator'
-  | 'blob-type'
-  | 'cycle'
-  | 'form-data-roundtrip'
-  | 'referenced-form-data';
-
-const resolvePackage = createRequire(
-  path.join(__dirname, 'rsc-decoder-security-resolver.cjs'),
-).resolve;
-const childPath = path.join(
-  __dirname,
-  'fixtures',
-  'rscDecoderSecurityChild.cjs',
-);
-
-function runDecoderScenario(options: {
-  entry: 'edge' | 'node';
-  nodeEnv: 'development' | 'production';
-  scenario: DecoderScenario;
-}): Record<string, unknown> {
-  const result = spawnSync(
-    process.execPath,
-    [
-      '--conditions=react-server',
-      childPath,
-      options.scenario,
-      resolvePackage(`react-server-dom-rspack/server.${options.entry}`),
-      resolvePackage(`react-server-dom-rspack/client.${options.entry}`),
-    ],
-    {
-      encoding: 'utf8',
-      env: { ...process.env, NODE_ENV: options.nodeEnv },
-      timeout: 5_000,
-    },
-  );
-
-  if (result.error || result.status !== 0) {
-    throw new Error(
-      [
-        `RSC decoder child failed for ${options.entry}/${options.nodeEnv}/${options.scenario}`,
-        result.stdout,
-        result.stderr,
-      ]
-        .filter(Boolean)
-        .join('\n'),
-      { cause: result.error },
-    );
-  }
-
-  return JSON.parse(result.stdout) as Record<string, unknown>;
-}
-
-for (const entry of ['node', 'edge'] as const) {
-  for (const nodeEnv of ['development', 'production'] as const) {
-    describe(`${entry} ${nodeEnv} Flight decoder security`, () => {
-      test('bounds cyclic Map reconstruction before invoking constructors', () => {
-        expect(
-          runDecoderScenario({ entry, nodeEnv, scenario: 'cycle' }),
-        ).toEqual({
-          mapArrayConstructions: 2,
-          rejected: true,
-        });
-      });
-
-      test('decodes referenced FormData with one backing-store enumeration', () => {
-        expect(
-          runDecoderScenario({
-            entry,
-            nodeEnv,
-            scenario: 'referenced-form-data',
-          }),
-        ).toEqual({ keyIterations: 1, values: ['first', 'second'] });
-      });
-
-      test('round-trips referenced FormData through the public client and server APIs', () => {
-        expect(
-          runDecoderScenario({
-            entry,
-            nodeEnv,
-            scenario: 'form-data-roundtrip',
-          }),
-        ).toEqual({ values: ['first', 'second'] });
-      });
-
-      test('rejects a Blob reference backed by a string', () => {
-        expect(
-          runDecoderScenario({ entry, nodeEnv, scenario: 'blob-type' }),
-        ).toEqual({
-          rejected: true,
-          returnedString: false,
-        });
-      });
-
-      test('does not recursively throw into a rejecting async iterator', () => {
-        expect(
-          runDecoderScenario({ entry, nodeEnv, scenario: 'async-iterator' }),
-        ).toEqual({ throwCalls: 1 });
-      });
-
-      test('loads one server module for eight distinct action identifiers', () => {
-        expect(
-          runDecoderScenario({ entry, nodeEnv, scenario: 'action-load' }),
-        ).toEqual({ moduleLoads: 1, submittedEntries: [] });
-      });
-    });
-  }
-}

package/tests/router/rscPayloadRouterMatrix.test.ts

@@ -1,197 +0,0 @@
-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',
-      },
-    ]);
-  });
-});