@nocobase/client-v2 2.1.31 → 2.2.0-alpha.10

package/src/__tests__/RouteRepository.test.ts

@@ -0,0 +1,239 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import type { NocoBaseDesktopRoute } from '../flow-compat';
+import { RouteRepository } from '../RouteRepository';
+
+function createRouteRepository() {
+  const request = vi.fn().mockResolvedValue({
+    data: {
+      data: [],
+    },
+  });
+  const create = vi.fn().mockResolvedValue({
+    data: {
+      data: {},
+    },
+  });
+  const resource = vi.fn(() => ({
+    create,
+  }));
+  const repository = new RouteRepository({
+    api: {
+      request,
+      resource,
+    },
+  } as never);
+
+  return {
+    create,
+    repository,
+    request,
+    resource,
+  };
+}
+
+function route(schemaUid: string): NocoBaseDesktopRoute {
+  return { schemaUid } as NocoBaseDesktopRoute;
+}
+
+describe('RouteRepository', () => {
+  it('should pass the default admin layout when loading accessible routes', async () => {
+    const { repository, request } = createRouteRepository();
+
+    await repository.refreshAccessible();
+
+    expect(request).toHaveBeenCalledWith({
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'admin-layout-model',
+      },
+    });
+  });
+
+  it('should pass the active client-v2 layout when loading accessible routes', async () => {
+    const { repository, request } = createRouteRepository();
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+
+    await repository.refreshAccessible();
+    deactivateLayout();
+
+    expect(request).toHaveBeenCalledWith({
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'custom-desktop-layout-model',
+      },
+    });
+  });
+
+  it('should reload accessible routes when the active client-v2 layout changes', async () => {
+    const { repository, request } = createRouteRepository();
+    const deactivateFirstLayout = repository.activateLayout({
+      uid: 'first-layout-model',
+    });
+    await repository.ensureAccessibleLoaded();
+    deactivateFirstLayout();
+
+    const deactivateSecondLayout = repository.activateLayout({
+      uid: 'second-layout-model',
+    });
+    await repository.ensureAccessibleLoaded();
+    deactivateSecondLayout();
+
+    expect(request).toHaveBeenNthCalledWith(1, {
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'first-layout-model',
+      },
+    });
+    expect(request).toHaveBeenNthCalledWith(2, {
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'second-layout-model',
+      },
+    });
+  });
+
+  it('should report accessible routes as unloaded when the active layout changes', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([], 'first-layout-model');
+    const deactivateLayout = repository.activateLayout({
+      uid: 'second-layout-model',
+    });
+
+    expect(repository.isAccessibleLoaded()).toBe(false);
+    deactivateLayout();
+  });
+
+  it('should keep accessible route caches isolated by active layout', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([route('admin-page')], 'admin-layout-model');
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+    repository.setRoutes([route('custom-page')], 'custom-desktop-layout-model');
+
+    expect(repository.listAccessible().map((route) => route.schemaUid)).toEqual(['custom-page']);
+    expect(repository.getRouteBySchemaUid('admin-page')).toBeUndefined();
+    deactivateLayout();
+
+    expect(repository.listAccessible().map((route) => route.schemaUid)).toEqual(['admin-page']);
+    expect(repository.getRouteBySchemaUid('custom-page')).toBeUndefined();
+  });
+
+  it('should find nested routes by id', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([
+      {
+        id: 1,
+        schemaUid: 'group-1',
+        children: [
+          {
+            id: 11,
+            schemaUid: 'page-1',
+          },
+        ],
+      },
+    ] as NocoBaseDesktopRoute[]);
+
+    expect(repository.getRouteById('11')).toMatchObject({
+      id: 11,
+      schemaUid: 'page-1',
+    });
+    expect(repository.getRouteById('missing')).toBeUndefined();
+  });
+
+  it('should notify only subscribers for the changed layout cache', () => {
+    const { repository } = createRouteRepository();
+    const adminEvents: string[][] = [];
+    const customEvents: string[][] = [];
+
+    const unsubscribeAdmin = repository.subscribe(() => {
+      adminEvents.push(repository.listAccessible().map((route) => route.schemaUid || ''));
+    });
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+    const unsubscribeCustom = repository.subscribe(() => {
+      customEvents.push(repository.listAccessible().map((route) => route.schemaUid || ''));
+    });
+
+    repository.setRoutes([route('custom-page')], 'custom-desktop-layout-model');
+
+    expect(adminEvents).toEqual([]);
+    expect(customEvents).toEqual([['custom-page']]);
+
+    deactivateLayout();
+    repository.setRoutes([route('admin-page')], 'admin-layout-model');
+
+    expect(adminEvents).toEqual([['admin-page']]);
+    expect(customEvents).toEqual([['custom-page']]);
+
+    unsubscribeAdmin();
+    unsubscribeCustom();
+  });
+
+  it('should pass the default admin layout when creating a route', async () => {
+    const { repository, create } = createRouteRepository();
+
+    await repository.createRoute(
+      {
+        title: 'Admin page',
+      },
+      {
+        refreshAfterMutation: false,
+      },
+    );
+
+    expect(create).toHaveBeenCalledWith({
+      values: {
+        title: 'Admin page',
+      },
+      layout: 'admin-layout-model',
+    });
+  });
+
+  it('should pass the active client-v2 layout when creating a route', async () => {
+    const { repository, create } = createRouteRepository();
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+
+    await repository.createRoute(
+      {
+        title: 'Custom page',
+      },
+      {
+        refreshAfterMutation: false,
+      },
+    );
+    deactivateLayout();
+
+    expect(create).toHaveBeenCalledWith({
+      values: {
+        title: 'Custom page',
+      },
+      layout: 'custom-desktop-layout-model',
+    });
+  });
+});

package/src/__tests__/RouterManager.test.ts

@@ -0,0 +1,125 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { BaseApplication } from '../BaseApplication';
+import { RouterManager, shouldOpenAdminRouteInNewWindow } from '../RouterManager';
+
+describe('RouterManager', () => {
+  describe('shouldOpenAdminRouteInNewWindow', () => {
+    it('opens admin route in a new window from a non-admin portal', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports target pathname with the v2 base path', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/nocobase/v/test',
+          targetPathname: '/nocobase/v/admin/settings',
+          basePath: '/nocobase/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports custom portal routes in sub-apps', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('keeps admin route navigation in the current window when already in sub-app admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/admin',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps admin route navigation in the current window when already in admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/admin',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps non-admin portal navigation in the current window', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/test/page',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('does not intercept replace navigation or relative paths', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+          replace: true,
+        }),
+      ).toBe(false);
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: 'admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+  });
+
+  it('opens admin route in a new window through the underlying router navigate from a sub-app portal', async () => {
+    const app = {
+      name: 'a_9xlild35jir',
+      getPublicPath: () => '/v/',
+      getHref: (pathname: string) => `/v/apps/a_9xlild35jir/${pathname.replace(/^\/+/, '')}`,
+      layoutManager: {
+        getLayout: () => ({ routePath: '/admin' }),
+      },
+      renderComponent: () => null,
+    } as unknown as BaseApplication<unknown>;
+    const manager = new RouterManager({ type: 'browser' }, app);
+    const open = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    window.history.pushState({}, '', '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu');
+    manager.getRouterComponent();
+    await manager.router.navigate('/admin/settings/version-control/list');
+
+    expect(open).toHaveBeenCalledWith(
+      '/v/apps/a_9xlild35jir/admin/settings/version-control/list',
+      '_blank',
+      'noopener,noreferrer',
+    );
+  });
+});

package/src/__tests__/app.test.tsx

@@ -52,6 +52,24 @@ describe('app', () => {
       expect(app.getHref('/test')).toBe('/test');
     });
 
+    it('should enable credentials for api clients by default', () => {
+      const sameOriginApp = new Application({
+        router,
+        apiClient: {
+          baseURL: '/api/',
+        },
+      });
+      const crossOriginApp = new Application({
+        router,
+        apiClient: {
+          baseURL: 'https://api.example.com/api/',
+        },
+      });
+
+      expect(sameOriginApp.apiClient.axios.defaults.withCredentials).toBe(true);
+      expect(crossOriginApp.apiClient.axios.defaults.withCredentials).toBe(true);
+    });
+
     it('should initialize shared jsonLogic operators', () => {
       const app = new Application({ router });
 

package/src/__tests__/authRedirect.test.ts

@@ -10,6 +10,7 @@
 import {
   buildV2SigninHref,
   getCurrentV2RedirectPath,
+  normalizeV2RedirectPath,
   redirectToV2Signin,
   resolveV2SigninRedirect,
 } from '../authRedirect';
@@ -133,6 +134,22 @@ describe('auth redirect helpers', () => {
   });
 
   describe('v2 sub-app context (router basename contains /apps/<id>/)', () => {
+    it('should normalize signin redirect fallback under the current sub-app basename', () => {
+      const app = {
+        getPublicPath: () => '/v/',
+        router: {
+          getBasename: () => '/v/apps/test-app/',
+        },
+      } as any;
+
+      expect(normalizeV2RedirectPath(app, '')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/admin/?tab=overview#panel')).toBe(
+        '/v/apps/test-app/admin/?tab=overview#panel',
+      );
+      expect(normalizeV2RedirectPath(app, '/v/apps/test-app/admin/')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/v/admin/')).toBe('/v/apps/test-app/admin/');
+    });
+
     it('should preserve sub-app segment when building current redirect path under simple public path', () => {
       const app = {
         getPublicPath: () => '/v2/',

package/src/__tests__/browserChecker.test.ts

@@ -15,6 +15,8 @@ import { fileURLToPath } from 'node:url';
 type BrowserCheckerCase = {
   pathname: string;
   publicPath: string;
+  modernClientPrefix?: string;
+  appClientEntryMode?: string;
   expectedRedirect?: string;
 };
 
@@ -40,6 +42,8 @@ function executeBrowserChecker(scriptPath: string, input: BrowserCheckerCase) {
     showLog: false,
     window: {
       __nocobase_public_path__: input.publicPath,
+      __nocobase_modern_client_prefix__: input.modernClientPrefix,
+      __nocobase_app_client_entry_mode__: input.appClientEntryMode,
       location: {
         origin: 'http://c.local.nocobase.com',
         pathname: input.pathname,
@@ -109,4 +113,61 @@ describe.each(browserCheckerCases)('$label', ({ scriptPath }) => {
 
     expect(replace).not.toHaveBeenCalled();
   });
+
+  if (scriptPath.includes('/app/client/public/')) {
+    it('redirects app root to modern entry for modern-default', () => {
+      const replace = executeBrowserChecker(scriptPath, {
+        pathname: '/',
+        publicPath: '/',
+        modernClientPrefix: 'v',
+        appClientEntryMode: 'modern-default',
+      });
+
+      expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/v/');
+    });
+
+    it('does not redirect legacy deep links for modern-default', () => {
+      const replace = executeBrowserChecker(scriptPath, {
+        pathname: '/admin',
+        publicPath: '/',
+        modernClientPrefix: 'v',
+        appClientEntryMode: 'modern-default',
+      });
+
+      expect(replace).not.toHaveBeenCalled();
+    });
+
+    it('rewrites legacy document paths for modern-only', () => {
+      const replace = executeBrowserChecker(scriptPath, {
+        pathname: '/admin/settings/workflow',
+        publicPath: '/',
+        modernClientPrefix: 'v',
+        appClientEntryMode: 'modern-only',
+      });
+
+      expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/v/admin/settings/workflow');
+    });
+
+    it('redirects sub-path site root directly to final modern target', () => {
+      const replace = executeBrowserChecker(scriptPath, {
+        pathname: '/nocobase/',
+        publicPath: '/nocobase/',
+        modernClientPrefix: 'v',
+        appClientEntryMode: 'modern-default',
+      });
+
+      expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/nocobase/v/');
+    });
+
+    it('rewrites sub-app legacy deep links for modern-only without collapsing the sub-app segment', () => {
+      const replace = executeBrowserChecker(scriptPath, {
+        pathname: '/nocobase/apps/a_31itq60q4kg/admin/',
+        publicPath: '/nocobase/',
+        modernClientPrefix: 'v',
+        appClientEntryMode: 'modern-only',
+      });
+
+      expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/nocobase/v/apps/a_31itq60q4kg/admin');
+    });
+  }
 });

package/src/__tests__/exports.test.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { IconPicker } from '..';
+
+describe('@nocobase/client-v2 exports', () => {
+  it('should export IconPicker from the root entry', () => {
+    expect(IconPicker).toBeDefined();
+  });
+});

package/src/__tests__/getRouteRuntimeVersion.test.ts

@@ -0,0 +1,68 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { afterEach, describe, expect, it } from 'vitest';
+import { getRouteRuntimeVersion } from '../utils/getRouteRuntimeVersion';
+
+function replacePathname(pathname: string) {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: {
+      ...window.location,
+      pathname,
+    },
+  });
+}
+
+describe('getRouteRuntimeVersion', () => {
+  afterEach(() => {
+    delete window.__nocobase_modern_client_prefix__;
+    delete window.__nocobase_public_path__;
+    replacePathname('/');
+  });
+
+  it('returns modern when the current pathname is inside the modern client prefix', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/nocobase/v/';
+    replacePathname('/nocobase/v/admin/settings/workflow');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+
+  it('returns legacy when reused v2 components run under the v1 settings page', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/nocobase/';
+    replacePathname('/nocobase/admin/settings/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('legacy');
+  });
+
+  it('returns legacy when root public path is "/"', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/';
+    replacePathname('/admin/settings/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('legacy');
+  });
+
+  it('returns modern when root public path is "/v/"', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    window.__nocobase_public_path__ = '/v/';
+    replacePathname('/v/admin/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+
+  it('falls back to pathname matching when public path is unavailable', () => {
+    window.__nocobase_modern_client_prefix__ = 'v';
+    replacePathname('/v/admin/workflow/workflows/123');
+
+    expect(getRouteRuntimeVersion()).toBe('modern');
+  });
+});

package/src/__tests__/nocobase-buildin-plugin-auth.test.tsx

@@ -55,6 +55,7 @@ describe('nocobase buildin plugin auth redirect', () => {
   const originalLocation = globalThis.window.location;
 
   beforeEach(() => {
+    globalThis.window.localStorage.clear();
     // These fixtures mount the modern client under the `v2` segment; tell the
     // runtime-prefix helper so v2-runtime detection matches (server injects it
     // in production).
@@ -75,6 +76,7 @@ describe('nocobase buildin plugin auth redirect', () => {
   });
 
   afterEach(() => {
+    globalThis.window.localStorage.clear();
     delete (globalThis.window as any).__nocobase_modern_client_prefix__;
     Object.defineProperty(globalThis.window, 'location', {
       configurable: true,
@@ -116,6 +118,7 @@ describe('nocobase buildin plugin auth redirect', () => {
       plugins: [NocoBaseBuildInPlugin as any],
       router: { type: 'memory', initialEntries: ['/v2/admin'] },
     });
+    app.apiClient.auth.setToken('test-token');
     app.apiMock.onGet('app:getLang').reply(200, {
       data: { lang: 'en-US', resources: { client: {} }, cron: {} },
     });
@@ -130,6 +133,7 @@ describe('nocobase buildin plugin auth redirect', () => {
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(app.router.router.state.location.pathname).toBe('/v2/admin');
     expect(app.router.router.state.location.search).toBe('');
+    expect(app.apiMock.history.post.filter((request) => request.url === 'auth:syncCookies')).toHaveLength(0);
   });
 
   it('should redirect unauthenticated v2 root access to v2 signin via <Navigate />', async () => {
@@ -326,6 +330,29 @@ describe('nocobase buildin plugin auth redirect', () => {
       data: { lang: 'en-US', resources: { client: {} }, cron: {} },
     });
     app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
+    app.apiMock.onPost('auth:syncCookies').reply(200, { data: { synced: true } });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    expect(await screen.findByText('secure page')).toBeInTheDocument();
+    expect(ensureLoaded).toHaveBeenCalledTimes(1);
+    expect(app.apiMock.history.post.filter((request) => request.url === 'auth:syncCookies')).toHaveLength(1);
+  });
+
+  it('should keep authenticated v2 startup working when cookie bootstrap fails', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, AuthBootstrapRoutePlugin as any],
+      router: { type: 'memory', initialEntries: ['/v2/secure'] },
+    });
+    app.apiClient.auth.setToken('test-token');
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
+    app.apiMock.onPost('auth:syncCookies').reply(500, { errors: [{ message: 'cookie sync failed' }] });
     const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
 
     const Root = app.getRootComponent();
@@ -333,6 +360,7 @@ describe('nocobase buildin plugin auth redirect', () => {
 
     expect(await screen.findByText('secure page')).toBeInTheDocument();
     expect(ensureLoaded).toHaveBeenCalledTimes(1);
+    expect(app.apiMock.history.post.filter((request) => request.url === 'auth:syncCookies')).toHaveLength(1);
   });
 
   it('should not auth-check or bootstrap authCheck false routes', async () => {