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

package/tests/localisedRouteGeneration.test.ts

@@ -0,0 +1,200 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import { createAsyncHook, createPluginManager } from '@modern-js/plugin';
+import {
+  createContext,
+  initAppContext,
+  initPluginAPI,
+} from '@modern-js/plugin/cli';
+import type { NestedRouteForCli } from '@modern-js/types';
+import { describe, expect, test } from '@rstest/core';
+import { type I18nPluginOptions, i18nPlugin } from '../src/cli';
+
+/**
+ * Localised route generation must reach a bare `appTools()` consumer.
+ *
+ * The fork used to register it only from `@modern-js/i18n-integration`, which
+ * `ultramodernAppTools()` composes but plain `appTools()` does not — so an app
+ * declaring `localeDetection.localisedUrls` got a 404 on every mapped path
+ * under SSR. These cases deliberately register *only* the native plugin, with
+ * no integration plugin in the manager, so a regression back to the opt-in
+ * wiring fails here.
+ */
+
+const createRoute = (
+  path: string,
+  children?: NestedRouteForCli[],
+): NestedRouteForCli => ({
+  id: path,
+  path,
+  type: 'nested',
+  origin: 'file-system',
+  routeType: children ? 'layout' : 'page',
+  _component: `${path}.tsx`,
+  children,
+});
+
+async function createNativeOnlyHarness(options: I18nPluginOptions = {}) {
+  const manager = createPluginManager();
+  const routeHost: CliPlugin<AppTools> = {
+    name: 'test-route-host',
+    registryHooks: { modifyFileSystemRoutes: createAsyncHook<any>() },
+    setup() {
+      // Only supplies the hook registry the app-tools router owns.
+    },
+  };
+
+  manager.addPlugins([i18nPlugin(options), routeHost]);
+  const plugins = manager.getPlugins() as CliPlugin<AppTools>[];
+  const context = await createContext<AppTools>({
+    appContext: initAppContext({
+      packageName: 'plugin-i18n-native-only-test',
+      configFile: false,
+      command: 'build',
+      appDirectory: process.cwd(),
+      metaName: 'modern-js',
+      plugins,
+    }),
+    config: {},
+    normalizedConfig: {} as any,
+  });
+  const api = initPluginAPI<AppTools>({ context, pluginManager: manager });
+  for (const plugin of plugins) {
+    await plugin.setup?.(api);
+  }
+  return api.getHooks().modifyFileSystemRoutes.call;
+}
+
+const entrypoint = { entryName: 'main' } as any;
+
+const localisedUrls = {
+  '/about': { en: '/about', cs: '/o-nas' },
+  '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' },
+};
+
+describe('native localised route generation', () => {
+  test('expands mapped locale paths without the integration plugin', async () => {
+    const modifyRoutes = await createNativeOnlyHarness({
+      localeDetection: {
+        localePathRedirect: true,
+        languages: ['en', 'cs'],
+        localisedUrls,
+      },
+    });
+
+    const result = await modifyRoutes({
+      entrypoint,
+      routes: [
+        createRoute(':lang', [
+          createRoute('about'),
+          createRoute('products/:slug'),
+        ]),
+      ],
+    });
+
+    const paths = result.routes[0].children?.map(
+      (route: NestedRouteForCli) => route.path,
+    );
+    expect(paths).toContain('about');
+    expect(paths).toContain('o-nas');
+    expect(paths).toContain('products/:slug');
+    expect(paths).toContain('produkty/:slug');
+  });
+
+  test('keeps one source identity for TanStack entries while validating locale mappings', async () => {
+    const modifyRoutes = await createNativeOnlyHarness({
+      localeDetection: {
+        localePathRedirect: true,
+        languages: ['en', 'cs'],
+        localisedUrls,
+      },
+    });
+    const result = await modifyRoutes({
+      entrypoint: {
+        ...entrypoint,
+        __modernRoutesOwner: '@modern-js/plugin-tanstack',
+      },
+      routes: [
+        createRoute(':lang', [
+          createRoute('about'),
+          createRoute('products/:slug'),
+        ]),
+      ],
+    });
+    expect(result.routes[0].children).toMatchObject([
+      {
+        id: 'about',
+        path: 'about',
+        modernLocalisedRoute: {
+          canonicalPath: '/about',
+          paths: localisedUrls['/about'],
+        },
+      },
+      {
+        id: 'products/:slug',
+        path: 'products/:slug',
+        modernLocalisedRoute: {
+          canonicalPath: '/products/:slug',
+          paths: localisedUrls['/products/:slug'],
+        },
+      },
+    ]);
+    expect(result.routes[0].children).toHaveLength(2);
+  });
+
+  test('leaves routes untouched when no map is declared', async () => {
+    const modifyRoutes = await createNativeOnlyHarness({
+      localeDetection: {
+        localePathRedirect: true,
+        languages: ['en', 'cs'],
+      },
+    });
+
+    const input = [createRoute(':lang', [createRoute('about')])];
+    const result = await modifyRoutes({ entrypoint, routes: input });
+
+    expect(
+      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
+    ).toEqual(['about']);
+  });
+
+  test('leaves routes untouched without localePathRedirect', async () => {
+    const modifyRoutes = await createNativeOnlyHarness({
+      localeDetection: {
+        languages: ['en', 'cs'],
+        localisedUrls,
+      },
+    });
+
+    const input = [createRoute(':lang', [createRoute('about')])];
+    const result = await modifyRoutes({ entrypoint, routes: input });
+
+    expect(
+      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
+    ).toEqual(['about']);
+  });
+
+  test('resolves the map from a per-entry locale detection override', async () => {
+    const modifyRoutes = await createNativeOnlyHarness({
+      localeDetection: {
+        localePathRedirect: true,
+        languages: ['en'],
+        localeDetectionByEntry: {
+          main: {
+            localePathRedirect: true,
+            languages: ['en', 'cs'],
+            localisedUrls,
+          },
+        },
+      },
+    });
+
+    const result = await modifyRoutes({
+      entrypoint,
+      routes: [createRoute(':lang', [createRoute('about')])],
+    });
+
+    expect(
+      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
+    ).toContain('o-nas');
+  });
+});

package/tests/localisedUrls.test.ts

@@ -1,4 +1,3 @@
-import type { NestedRouteForCli } from '@modern-js/types';
 import { describe, expect, test } from '@rstest/core';
 import { i18nPlugin as i18nCliPlugin } from '../src/cli';
 import {
@@ -7,19 +6,6 @@ import {
   matchesApiPrefix,
 } from '../src/server';
 
-const createRoute = (
-  path: string,
-  children?: NestedRouteForCli[],
-): NestedRouteForCli => ({
-  id: path,
-  path,
-  type: 'nested',
-  origin: 'file-system',
-  routeType: children ? 'layout' : 'page',
-  _component: `${path}.tsx`,
-  children,
-});
-
 const createRequestContext = (pathname: string) =>
   ({
     req: {
@@ -63,149 +49,33 @@ describe('cli modifyFileSystemRoutes', () => {
     expect(runtimePlugin?.config.reactI18next).toBe(false);
   });
 
-  const setupModifyRoutes = (localeDetection: Record<string, unknown>) => {
-    let modifyRoutes:
-      | ((args: { entrypoint: any; routes: any[] }) => {
-          entrypoint: any;
-          routes: any[];
-        })
+  test('upstream-style configs without a map keep routes untouched', async () => {
+    // The hook is registered unconditionally now that route expansion is a
+    // native feature; what matters is that a config with no `localisedUrls`
+    // map gets its routes back byte-for-byte instead of a locale-expanded tree.
+    let handler:
+      | ((args: { entrypoint: unknown; routes: unknown[] }) => Promise<{
+          routes: unknown[];
+        }>)
       | undefined;
 
-    i18nCliPlugin({ localeDetection }).setup({
+    i18nCliPlugin({
+      localeDetection: { localePathRedirect: true, languages: ['en', 'cs'] },
+    }).setup({
       _internalRuntimePlugins: () => {},
+      _internalServerPlugins: () => {},
       modifyFileSystemRoutes: (fn: any) => {
-        modifyRoutes = fn;
+        handler = fn;
       },
-      _internalServerPlugins: () => {},
     } as any);
 
-    expect(modifyRoutes).toBeDefined();
-    return modifyRoutes!;
-  };
-
-  const generateLocalisedRoutes = () => {
-    const modifyRoutes = setupModifyRoutes({
-      localePathRedirect: true,
-      languages: ['en', 'cs', 'de'],
-      localisedUrls: {
-        '/about': {
-          en: '/about',
-          cs: '/o-nas',
-          de: '/ueber-uns',
-        },
-        '/products': {
-          en: '/products',
-          cs: '/produkty',
-          de: '/produkte',
-        },
-        '/products/:slug': {
-          en: '/products/:slug',
-          cs: '/produkty/:slug',
-          de: '/produkte/:slug',
-        },
-        '/docs': {
-          en: '/docs',
-          cs: '/dokumenty',
-          de: '/dokumente',
-        },
-        '/docs/*': {
-          en: '/docs/*',
-          cs: '/dokumenty/*',
-          de: '/dokumente/*',
-        },
-      },
-    });
-    const routes = [
-      createRoute(':lang', [
-        createRoute('about'),
-        createRoute('products', [createRoute(':slug')]),
-        createRoute('docs', [createRoute('*')]),
-      ]),
-    ];
-
-    const result = modifyRoutes({
+    const routes = [{ id: 'about', path: 'about', type: 'nested' }];
+    const result = await handler?.({
       entrypoint: { entryName: 'main' },
       routes,
     });
 
-    return result.routes;
-  };
-
-  test('creates deterministic localized aliases with canonical route identity', () => {
-    const localisedRoutes = generateLocalisedRoutes();
-    expect(generateLocalisedRoutes()).toEqual(localisedRoutes);
-
-    const [localeLayout] = localisedRoutes;
-    expect(localeLayout.children?.map(route => route.path)).toEqual([
-      'about',
-      'o-nas',
-      'ueber-uns',
-      'products',
-      'produkty',
-      'produkte',
-      'docs',
-      'dokumenty',
-      'dokumente',
-    ]);
-    expect(localeLayout.children?.slice(0, 3)).toMatchObject([
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'about',
-      },
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'o-nas',
-      },
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'ueber-uns',
-      },
-    ]);
-    for (const productRoute of localeLayout.children?.slice(3, 6) ?? []) {
-      expect(productRoute).toMatchObject({
-        _component: 'products.tsx',
-        modernCanonicalPath: '/products',
-      });
-      expect(productRoute.children?.[0]).toMatchObject({
-        _component: ':slug.tsx',
-        modernCanonicalPath: '/products/:slug',
-        path: ':slug',
-      });
-    }
-  });
-
-  test('upstream-style configs without a map keep routes untouched', () => {
-    const modifyRoutes = setupModifyRoutes({
-      localePathRedirect: true,
-      languages: ['en', 'cs'],
-    });
-    const routes = [createRoute(':lang', [createRoute('about')])];
-
-    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
-
-    expect(result.routes).toBe(routes);
-  });
-
-  test('a configured map still expands localised route aliases', () => {
-    const modifyRoutes = setupModifyRoutes({
-      localePathRedirect: true,
-      languages: ['en', 'cs'],
-      localisedUrls: {
-        '/about': { en: '/about', cs: '/o-nas' },
-      },
-    });
-    const routes = [createRoute(':lang', [createRoute('about')])];
-
-    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
-
-    const localeRoute = result.routes[0] as NestedRouteForCli;
-    expect(localeRoute.children?.map(route => route.path)).toEqual([
-      'about',
-      'o-nas',
-    ]);
+    expect(result?.routes).toEqual(routes);
   });
 });
 
@@ -283,68 +153,6 @@ describe('i18n server API prefix skips', () => {
     }
   });
 
-  test('canonical redirect survives malformed percent-encoding', async () => {
-    const middlewares: any[] = [];
-    const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];
-    let prepare: (() => void) | undefined;
-
-    i18nServerPlugin({
-      localeDetection: {
-        fallbackLanguage: 'en',
-        languages: ['en', 'cs'],
-        localePathRedirect: true,
-        localisedUrls: {
-          '/products/:slug': {
-            en: '/products/:slug',
-            cs: '/produkty/:slug',
-          },
-        },
-      },
-      staticRoutePrefixes: [],
-    }).setup({
-      getServerConfig: () => ({}),
-      getServerContext: () => ({ middlewares, routes }),
-      onPrepare: fn => {
-        prepare = fn;
-      },
-    } as any);
-
-    prepare?.();
-
-    const redirectMiddleware = middlewares.find(
-      middleware => middleware.name === 'i18n-server-middleware',
-    );
-    const createContext = (pathname: string) =>
-      ({
-        req: {
-          url: `http://localhost${pathname}`,
-          header: () => ({ host: 'localhost' }),
-        },
-        get: () => null,
-      }) as any;
-
-    // Sanity: well-formed non-canonical slugs still redirect.
-    const redirected = await redirectMiddleware.handler(
-      createContext('/cs/products/bota'),
-      async () => {},
-    );
-    expect(redirected.status).toBe(302);
-    expect(redirected.headers.get('location')).toBe('/cs/produkty/bota');
-    expect(redirected.headers.get('cache-control')).toBe('private, no-store');
-    expect(redirected.headers.get('vary')).toBe('Accept-Language, Cookie');
-
-    // Malformed encoding must fall through to next() instead of throwing.
-    let nextCalls = 0;
-    const response = await redirectMiddleware.handler(
-      createContext('/cs/produkty/%E0%A4%A'),
-      async () => {
-        nextCalls++;
-      },
-    );
-    expect(response).toBeUndefined();
-    expect(nextCalls).toBe(1);
-  });
-
   test('uses /api as the BFF prefix when BFF config is present without prefix', async () => {
     const middlewares: any[] = [];
     const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];

package/tests/mappedUrlStrategyDerivation.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from '@rstest/core';
+import { resolveMappedUrlStrategy } from '../src/shared/mappedUrlStrategy';
+
+/**
+ * Mapped locale URLs must work for a bare `appTools()` consumer that only
+ * declares `localeDetection.localisedUrls`. The map is plain data, so it
+ * survives the JSON boundary a `urlStrategy` object does not; the runtime
+ * derives its policy from it, and the server derives the same policy from the
+ * same shared module.
+ */
+
+const localisedUrls = {
+  '/terms-of-service': { en: '/terms-of-service', cs: '/obchodni-podminky' },
+  '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' },
+};
+const languages = ['en', 'cs'];
+
+describe('mapped url strategy derivation', () => {
+  test('derives a localizing strategy from localisedUrls', () => {
+    const strategy = resolveMappedUrlStrategy({ localisedUrls });
+
+    expect(strategy).toBeDefined();
+    expect(
+      strategy?.localizePathname?.('/terms-of-service', 'cs', languages),
+    ).toBe('/cs/obchodni-podminky');
+    expect(
+      strategy?.localizePathname?.('/terms-of-service', 'en', languages),
+    ).toBe('/en/terms-of-service');
+    expect(
+      strategy?.canonicalPathname?.('/cs/obchodni-podminky', languages),
+    ).toBe('/terms-of-service');
+  });
+
+  test('round-trips a parameterised mapped route', () => {
+    const strategy = resolveMappedUrlStrategy({ localisedUrls });
+    const localized = strategy?.localizePathname?.(
+      '/products/widget',
+      'cs',
+      languages,
+    );
+
+    expect(localized).toBe('/cs/produkty/widget');
+    expect(strategy?.canonicalPathname?.(localized!, languages)).toBe(
+      '/products/widget',
+    );
+  });
+
+  test('leaves unmapped paths on the plain language prefix', () => {
+    const strategy = resolveMappedUrlStrategy({ localisedUrls });
+
+    expect(strategy?.localizePathname?.('/unmapped', 'cs', languages)).toBe(
+      '/cs/unmapped',
+    );
+  });
+
+  test('derives nothing without a usable map', () => {
+    expect(resolveMappedUrlStrategy(undefined)).toBeUndefined();
+    expect(resolveMappedUrlStrategy({})).toBeUndefined();
+    expect(resolveMappedUrlStrategy({ localisedUrls: {} })).toBeUndefined();
+    expect(resolveMappedUrlStrategy({ localisedUrls: true })).toBeUndefined();
+  });
+});