@nocobase/app-template-default 1.0.0-beta.87 → 1.0.0-beta.89

package/tests/client/back-button.test.tsx

@@ -8,6 +8,8 @@ import type { ReactElement, ReactNode } from 'react';
 import { createMemoryRouter, Outlet, RouterProvider } from 'react-router';
 import { describe, expect, it } from 'vitest';
 
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import { RouteTreeProvider } from '../../client/routing/route-context.js';
 import { BackButton } from '#components/back-button';
 
 import enUS from '../../client/locales/en-US.js';
@@ -41,6 +43,25 @@ function renderAt(url: string, child: ReactElement) {
     ],
     { initialEntries: [url] },
   );
+  const registered = ['/projects', '/overview'].map(
+    (path) =>
+      ({
+        path,
+        id: path,
+        name: path,
+        packageName: 'test',
+        auth: 'required',
+        authz: 'skip',
+        componentLoader: async () => ({ default: () => null }),
+      }) as AppClientRegisteredRoute,
+  );
+  // The provider needs to be within the router, so wrap each route's page.
+  const routes = router.routes;
+  for (const entry of routes) {
+    entry.element = (
+      <RouteTreeProvider routes={registered}>{entry.element}</RouteTreeProvider>
+    );
+  }
   render(<RouterProvider router={router} />, { wrapper: I18n });
   return router;
 }
@@ -77,4 +98,17 @@ describe('BackButton', () => {
       screen.getByRole('link', { name: 'Back to the overview' }),
     ).toHaveAttribute('href', '/overview');
   });
+  it.each(['https://example.com/overview', '//example.com', '/missing'])(
+    'falls back safely for %s without naming the invalid destination',
+    (to) => {
+      renderAt(
+        '/projects/12',
+        <BackButton to={to}>Private destination</BackButton>,
+      );
+      expect(
+        screen.getByRole('link', { name: enUS.navigation.back }),
+      ).toHaveAttribute('href', '/projects');
+      expect(screen.queryByText('Private destination')).not.toBeInTheDocument();
+    },
+  );
 });

package/tests/client/client-auth.test.tsx

@@ -2,7 +2,13 @@ import {
   TestI18nProvider,
   createTestI18nRuntime,
 } from '@nocobase/i18n/testing';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import {
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react';
 import type { ReactElement } from 'react';
 import { MemoryRouter, Route, Routes } from 'react-router';
 import { describe, expect, it, vi } from 'vitest';
@@ -98,6 +104,9 @@ describe('application authentication pages', () => {
     });
     expect(panel).toHaveClass('hidden', 'xl:block');
     expect(panel).toHaveTextContent('AI-native application platform');
+    expect(within(panel).getByRole('heading', { level: 2 })).toHaveTextContent(
+      /^AI \+ NocoBase\s*Build reliable business systems$/,
+    );
     expect(panel).toHaveTextContent('AI-native frontend');
     expect(panel).toHaveTextContent('NocoBase foundation');
     expect(panel).toHaveTextContent('Freedom above. Confidence below.');

package/tests/client/client-route-recovery.test.tsx

@@ -2,7 +2,8 @@ import type {
   AppClientRegisteredRoute,
   AppClientRouteComponentModule,
 } from '@nocobase/app-client/plugins';
-import { act, screen } from '@testing-library/react';
+import { act, fireEvent, screen, waitFor } from '@testing-library/react';
+import { Activity, useState } from 'react';
 import { describe, expect, it } from 'vitest';
 
 import { ClientRoute } from '../../client/routing/client-route.tsx';
@@ -49,6 +50,97 @@ const healthyModule: AppClientRouteComponentModule = {
 };
 
 describe('client route loading recovery', () => {
+  it('keeps a loaded wrapped component when an ancestor Activity reconnects its effects', async () => {
+    let loads = 0;
+    const componentLoader = async () => {
+      loads += 1;
+      return {
+        default: function Editor() {
+          const [draft, setDraft] = useState('');
+          return (
+            <input
+              aria-label='Draft'
+              value={draft}
+              onChange={(event) => setDraft(event.target.value)}
+            />
+          );
+        },
+      };
+    };
+    const definition = { ...route, componentLoader };
+    const view = (hidden: boolean) => (
+      <Activity mode={hidden ? 'hidden' : 'visible'}>
+        <ClientRoute route={definition} />
+      </Activity>
+    );
+    const { rerender } = await renderWithApp(view(false), options);
+    const input = await screen.findByRole(
+      'textbox',
+      { name: 'Draft' },
+      ROUTE_LOAD_TIMEOUT,
+    );
+    fireEvent.change(input, { target: { value: 'Keep this draft' } });
+    rerender(view(true));
+    await waitFor(() => expect(input).not.toBeVisible());
+    rerender(view(false));
+    await waitFor(() => expect(input).toBeVisible());
+    expect(screen.getByRole('textbox', { name: 'Draft' })).toBe(input);
+    expect(input).toHaveValue('Keep this draft');
+    expect(loads).toBe(1);
+  });
+
+  it('loads a replacement after a successful module and ignores a superseded successful response', async () => {
+    const pending = Promise.withResolvers<AppClientRouteComponentModule>();
+    const { rerender } = await renderWithApp(
+      <ClientRoute
+        route={{ ...route, componentLoader: async () => healthyModule }}
+      />,
+      options,
+    );
+    await screen.findByText('Recovered page', {}, ROUTE_LOAD_TIMEOUT);
+    rerender(
+      <ClientRoute
+        route={{ ...route, componentLoader: () => pending.promise }}
+      />,
+    );
+    const replacement = { default: () => <h2>Replacement page</h2> };
+    rerender(
+      <ClientRoute
+        route={{ ...route, componentLoader: async () => replacement }}
+      />,
+    );
+    await screen.findByText('Replacement page', {}, ROUTE_LOAD_TIMEOUT);
+    await act(async () =>
+      pending.resolve({ default: () => <h2>Stale page</h2> }),
+    );
+    expect(screen.getByText('Replacement page')).toBeVisible();
+    expect(screen.queryByText('Stale page')).toBeNull();
+  });
+
+  it('invokes the same loader again on retry after a failed attempt', async () => {
+    let loads = 0;
+    const componentLoader = async () => {
+      loads += 1;
+      if (loads === 1) throw new Error('Temporary failure');
+      return healthyModule;
+    };
+    await renderWithApp(
+      <ClientRoute route={{ ...route, componentLoader }} />,
+      options,
+    );
+    fireEvent.click(
+      await screen.findByRole(
+        'button',
+        { name: 'Retry', exact: true },
+        ROUTE_LOAD_TIMEOUT,
+      ),
+    );
+    expect(
+      await screen.findByText('Recovered page', {}, ROUTE_LOAD_TIMEOUT),
+    ).toBeVisible();
+    expect(loads).toBe(2);
+  });
+
   it('clears a previous failure when the same mounted route loads successfully', async () => {
     const { rerender } = await renderWithApp(
       <ClientRoute route={route} />,

package/tests/client/client-routes.test.ts

@@ -6,9 +6,139 @@ import {
 import { describe, expect, it } from 'vitest';
 
 import systemSettingsRoutes from '../../client/pages/settings/routes.js';
-import applicationRoutes from '../../client/routes.ts';
+import applicationRoutes, {
+  createApplicationRoutes,
+} from '../../client/routes.ts';
+import { includeNotificationTemplateRoutes } from '../../client/pages/settings/notification-routes.js';
+import { defineAppRoutes } from '@nocobase/app-client/plugins';
 
 describe('app client routes', () => {
+  it('joins the settings system category across contributions without moving the log URL', () => {
+    const shell = defineAppRoutes([
+      {
+        name: 'settings',
+        path: '/settings',
+        navigation: { title: 'Settings' },
+        children: [
+          {
+            name: 'settingsSystem',
+            navigation: { title: 'System' },
+            children: [],
+          },
+        ],
+      },
+    ]);
+    const logs = defineAppRoutes([
+      {
+        name: 'notificationManagement',
+        parent: 'settingsSystem',
+        navigation: { title: 'Notifications' },
+        children: [
+          {
+            name: 'notificationLogs',
+            path: '/notifications/logs',
+            auth: 'required',
+            authz: {
+              resource: { type: 'page', id: 'notification.logs' },
+              action: 'access',
+            },
+            componentLoader: () =>
+              import('../../client/pages/settings/notification-templates.js'),
+          },
+        ],
+      },
+    ]);
+    const routes = includeNotificationTemplateRoutes([shell, logs], true);
+    const built = resolveAppClientContributions([
+      {
+        packageName: '@nocobase/app-template-default',
+        source: 'application',
+        routes,
+      },
+    ]);
+    expect(pagePaths(built.routes)).toEqual([
+      '/settings/notifications/logs',
+      '/settings/notifications/templates',
+    ]);
+    expect(built.routes[0].children[0].children).toHaveLength(1);
+    const created = includeNotificationTemplateRoutes([shell], true);
+    expect(
+      created
+        .flatMap((part) => part.routes)
+        .find((route) => route.name === 'notificationManagement')?.parent,
+    ).toBe('settingsSystem');
+  });
+
+  it('exposes configured invitation templates through the real application route factory', async () => {
+    const built = resolveAppClientContributions([
+      {
+        packageName: '@nocobase/app-template-default',
+        source: 'application',
+        routes: createApplicationRoutes({
+          notificationTemplates: { invitationConfigured: true },
+        }),
+      },
+    ]);
+    expect(pagePaths(built.routes)).toContain(
+      '/settings/notifications/templates',
+    );
+    expect(pageAuthorizations(built.routes)).toContainEqual({
+      name: 'notificationTemplates',
+      authorizedAs: 'notification.templates',
+    });
+    for (const loader of componentLoadersIn(built.routes))
+      await expect(loader()).resolves.toMatchObject({
+        default: expect.any(Function),
+      });
+  });
+
+  it('reuses the notification module and preserves its logs and existing grants', () => {
+    const existing = defineAppRoutes([
+      {
+        name: 'settings',
+        path: '/settings',
+        navigation: { title: 'Settings' },
+        children: [
+          {
+            name: 'notificationManagement',
+            navigation: { title: 'Notifications' },
+            children: [
+              {
+                name: 'notificationLogs',
+                path: '/notification-logs',
+                auth: 'required',
+                authz: {
+                  resource: { type: 'page', id: 'existing.notification.logs' },
+                  action: 'access',
+                },
+                componentLoader: () =>
+                  import('../../client/pages/settings/notification-templates.js'),
+              },
+            ],
+          },
+        ],
+      },
+    ]);
+    const once = includeNotificationTemplateRoutes([existing], false);
+    expect(includeNotificationTemplateRoutes(once, true)).toBe(once);
+    const built = resolveAppClientContributions([
+      {
+        packageName: '@nocobase/app-template-default',
+        source: 'application',
+        routes: once,
+      },
+    ]);
+    expect(pagePaths(built.routes)).toEqual([
+      '/settings/notification-logs',
+      '/settings/notifications/templates',
+    ]);
+    expect(pageAuthorizations(built.routes)).toEqual([
+      { name: 'notificationLogs', authorizedAs: 'existing.notification.logs' },
+      { name: 'notificationTemplates', authorizedAs: 'notification.templates' },
+    ]);
+    expect(built.routes[0].children).toHaveLength(1);
+  });
+
   it('keeps the landing page and the authentication pages', () => {
     // The authentication plugin and this application have to agree on these paths: it sends an unknown visitor to
     // /login, sends a signed-in user who opens a guest page back to /, and mails a reset link to /reset-password,
@@ -55,15 +185,17 @@ describe('app client routes', () => {
     expect(pageAuthorizations(resolved.routes)).toEqual([
       { name: 'home', authorizedAs: null },
       { name: 'inbox', authorizedAs: null },
+      { name: 'settingsHome', authorizedAs: null },
     ]);
   });
 
-  it('keeps a bare application home-only and supports settings registration as business capabilities are developed', async () => {
+  it('keeps a bare application free of settings modules and supports settings registration as business capabilities are developed', async () => {
+    // Only the settings home, which lists what the viewer may open and grants nothing itself.
     expect(
-      pagePaths(resolveRoutes().routes).some((path) =>
+      pagePaths(resolveRoutes().routes).filter((path) =>
         path.startsWith('/settings'),
       ),
-    ).toBe(false);
+    ).toEqual(['/settings']);
     const built = resolveAppClientContributions([
       {
         packageName: '@nocobase/app-template-default',
@@ -74,6 +206,7 @@ describe('app client routes', () => {
     expect(pageAuthorizations(built.routes)).toEqual([
       { name: 'home', authorizedAs: null },
       { name: 'inbox', authorizedAs: null },
+      { name: 'settingsHome', authorizedAs: null },
       { name: 'settingsUsers', authorizedAs: 'user:*' },
       { name: 'settingsUserCreate', authorizedAs: 'user:*' },
       { name: 'settingsUser', authorizedAs: 'user:*' },

package/tests/client/client-shell.test.tsx

@@ -5,6 +5,7 @@ import {
 import {
   apiClientToken,
   ClientApplicationContext,
+  NavigationGuardProvider,
   type ClientApplication,
   createAppClientConfig,
 } from '@nocobase/app-client';
@@ -89,15 +90,15 @@ describe('application shell', () => {
     expect(
       screen.queryByRole('link', { name: 'Settings' }),
     ).not.toBeInTheDocument();
-    expect(screen.getByText('AI builds freely.')).toBeVisible();
+    expect(screen.getByText('Build reliable business systems')).toBeVisible();
     expect(screen.getByRole('link', { name: 'NocoBase' })).toHaveAttribute(
       'href',
       'https://www.nocobase.com',
     );
     expect(
       screen.getByText('NocoBase', { selector: 'a' }).parentElement,
-    ).toHaveTextContent('NocoBase keeps it reliable.');
-    expect(screen.getByText('Default Template')).toHaveClass('truncate');
+    ).toHaveTextContent('AI + NocoBase');
+    expect(screen.queryByText('Default Template')).not.toBeInTheDocument();
     expect(screen.getByText('v0.0.0')).toHaveClass('truncate');
     // shadcn's edge rail, with a translated label in place of its built-in one.
     expect(
@@ -201,13 +202,25 @@ describe('application shell', () => {
     expect(
       await screen.findByRole('button', { name: 'Expand navigation' }),
     ).toHaveAttribute('aria-pressed', 'true');
-    // The footer keeps only its shield; focusing it shows the slogan, name and version.
+    // The footer keeps only its shield; focusing it shows the slogan and version.
     const footerIcon = screen.getByRole('img', {
-      name: 'AI builds freely. NocoBase keeps it reliable. Default Template v0.0.0',
+      name: 'AI + NocoBase Build reliable business systems v0.0.0',
     });
     act(() => footerIcon.focus());
     expect(
-      await screen.findByText('Default Template v0.0.0', {
+      await screen.findByText('v0.0.0', {
+        selector: '[data-slot="tooltip-content"] span',
+      }),
+    ).toBeVisible();
+
+    expect(screen.queryByText(/Default Template/)).not.toBeInTheDocument();
+    expect(
+      screen.getByText('AI + NocoBase', {
+        selector: '[data-slot="tooltip-content"] span',
+      }),
+    ).toBeVisible();
+    expect(
+      screen.getByText('Build reliable business systems', {
         selector: '[data-slot="tooltip-content"] span',
       }),
     ).toBeVisible();
@@ -223,7 +236,7 @@ describe('application shell', () => {
       ),
     );
     expect(
-      screen.queryByRole('img', { name: /Default Template/ }),
+      screen.queryByRole('img', { name: /AI \+ NocoBase/ }),
     ).not.toBeInTheDocument();
   });
 
@@ -316,7 +329,9 @@ function renderApplication(
             <SidebarPreferenceProvider
               value={createAppSidebarPreferenceStore('/main')}
             >
-              <AppRouter clientRoutes={clientRoutes} />
+              <NavigationGuardProvider>
+                <AppRouter clientRoutes={clientRoutes} />
+              </NavigationGuardProvider>
             </SidebarPreferenceProvider>
           </AppThemeProvider>
         </MemoryRouter>

package/tests/client/foundation-integration.test.ts

@@ -2,10 +2,14 @@ import { describe, expect, it } from 'vitest';
 import { resolveAppRuntime } from '@nocobase/app-client/runtime';
 import { defineAppRuntime } from '@nocobase/app-client/runtime';
 import appRuntime from '../../client/runtime.js';
+import { createApplicationRoutes } from '../../client/routes.js';
 import cliPlugins from '../../cli/plugins.js';
 import serverPlugins from '../../server/plugins.js';
 import settingsRoutes from '../../client/pages/settings/routes.js';
-import { buildRouteNavigation } from '../../client/routing/route-navigation.js';
+import {
+  buildRouteNavigation,
+  buildSettingsCatalog,
+} from '../../client/routing/route-navigation.js';
 
 describe('default Foundation integration', () => {
   it('registers the Foundation deployment evidence build hook', () => {
@@ -15,11 +19,18 @@ describe('default Foundation integration', () => {
       ),
     ).toHaveLength(1);
   });
-  it('exposes Foundation in settings for an unrestricted administrator and removes the empty group when denied', async () => {
+  it('exposes Foundation in System settings for an unrestricted administrator and removes the entry when denied', async () => {
     const runtime = await resolveAppRuntime(appRuntime);
     const menu = buildRouteNavigation(runtime.routes, new Set());
-    const group = menu.find(({ route }) => route.name === 'foundationSettings');
-    const page = group?.children.find(
+    // One System settings entry; Foundation is a card on its home, not a sidebar entry of its own.
+    expect(menu.map(({ route }) => route.name)).toEqual([
+      'home',
+      'settingsHome',
+    ]);
+    const category = buildSettingsCatalog(runtime.routes, new Set()).find(
+      ({ route }) => route.name === 'settingsSystem',
+    );
+    const page = category?.modules.find(
       ({ route }) => route.name === 'foundation',
     )?.route;
     expect(page).toMatchObject({
@@ -28,12 +39,13 @@ describe('default Foundation integration', () => {
       authz: 'unrestricted',
     });
     if (!page) throw new Error('Foundation route missing');
+    const denied = new Set([`${page.packageName}:${page.path}:${page.id}`]);
     expect(
-      buildRouteNavigation(
-        runtime.routes,
-        new Set([`${page.packageName}:${page.path}:${page.id}`]),
-      ).some(({ route }) => route.name === 'foundationSettings'),
-    ).toBe(false);
+      buildRouteNavigation(runtime.routes, denied).map(
+        ({ route }) => route.name,
+      ),
+    ).toEqual(['home']);
+    expect(buildSettingsCatalog(runtime.routes, denied)).toEqual([]);
     expect(
       serverPlugins.plugins.filter(
         (plugin) => plugin.packageName === '@nocobase/app-plugin-foundation',
@@ -41,22 +53,31 @@ describe('default Foundation integration', () => {
     ).toHaveLength(1);
   });
 
-  it('merges Foundation into business settings without changing its protected URL', async () => {
+  it('keeps Foundation beside business settings without changing its protected URL', async () => {
     const runtime = await resolveAppRuntime(
       defineAppRuntime({
         ...appRuntime,
-        routes: [...appRuntime.routes, settingsRoutes],
+        routes: () => [...createApplicationRoutes(), settingsRoutes],
       }),
     );
     const menu = buildRouteNavigation(runtime.routes, new Set());
     expect(menu.some(({ route }) => route.name === 'foundationSettings')).toBe(
       false,
     );
-    const settings = menu.find(({ route }) => route.name === 'settings');
-    expect(settings?.children.at(-1)?.route).toMatchObject({
-      name: 'foundation',
-      path: '/foundation',
-      authz: 'unrestricted',
-    });
+    expect(
+      buildSettingsCatalog(runtime.routes, new Set()).map((category) => [
+        category.route.name,
+        category.modules.map(({ route, target }) => [route.name, target.path]),
+      ]),
+    ).toEqual([
+      [
+        'settingsAccount',
+        [
+          ['settingsUsers', '/settings/users'],
+          ['permissionManagement', '/settings/roles'],
+        ],
+      ],
+      ['settingsSystem', [['foundation', '/foundation']]],
+    ]);
   });
 });

package/tests/client/layout-i18n.test.tsx

@@ -1,5 +1,6 @@
 import {
   ClientApplicationContext,
+  NavigationGuardProvider,
   type ClientApplication,
   createAppClientConfig,
 } from '@nocobase/app-client';
@@ -70,7 +71,9 @@ async function setup(children: ReactNode) {
     <I18nProvider runtime={runtime}>
       <ClientApplicationContext.Provider value={app}>
         <SidebarPreferenceProvider value={sidebarPreference}>
-          <MemoryRouter initialEntries={['/']}>{children}</MemoryRouter>
+          <MemoryRouter initialEntries={['/']}>
+            <NavigationGuardProvider>{children}</NavigationGuardProvider>
+          </MemoryRouter>
         </SidebarPreferenceProvider>
       </ClientApplicationContext.Provider>
     </I18nProvider>,
@@ -85,13 +88,15 @@ describe('shell translations', () => {
     expect(
       screen.getByRole('navigation', { name: 'Breadcrumb' }),
     ).toHaveTextContent('Overview');
-    expect(screen.getByText('AI builds freely.')).toBeVisible();
+    expect(screen.getByText('Build reliable business systems')).toBeVisible();
+    expect(screen.queryByText('Default Template')).not.toBeInTheDocument();
     await act(() => runtime.changeLanguage('zh-CN'));
     expect(screen.getByRole('navigation', { name: '面包屑' })).toBeVisible();
-    expect(screen.getByText('AI 自由构建')).toBeVisible();
+    expect(screen.getByText('Build reliable business systems')).toBeVisible();
+    expect(screen.queryByText('Default Template')).not.toBeInTheDocument();
     expect(
       screen.getByRole('link', { name: 'NocoBase' }).parentElement,
-    ).toHaveTextContent('NocoBase 保障可靠');
+    ).toHaveTextContent('AI + NocoBase');
     expect(
       screen.getByRole('button', { name: '展开或收起导航' }),
     ).toHaveAttribute('title', '展开或收起导航');

package/tests/client/list-feedback.test.tsx

@@ -97,7 +97,7 @@ describe('shared table and card feedback', () => {
       />,
       options,
     );
-    expect(screen.getByRole('status').textContent).toBe(
+    expect((await screen.findByRole('status')).textContent).toBe(
       enUS.listFeedback.loading,
     );
     expect(screen.getByRole('columnheader', { name: 'ID' })).toBeVisible();
@@ -159,7 +159,7 @@ describe('shared table and card feedback', () => {
       expect(
         screen.getByRole('button', { name: 'Search tools' }),
       ).toBeVisible();
-      expect(screen.getByRole(role).closest('td')).not.toBeNull();
+      expect((await screen.findByRole(role)).closest('td')).not.toBeNull();
     }
 
     view.rerender(
@@ -178,9 +178,8 @@ describe('shared table and card feedback', () => {
   });
 
   it('renders each built-in state as one icon and one short line without inline actions', async () => {
-    const view = await renderWithApp(<ListFeedback state='loading' />, options);
+    const view = await renderWithApp(<ListFeedback state='empty' />, options);
     const states = [
-      ['loading', 'status'],
       ['empty', 'status'],
       ['no-results', 'status'],
       ['forbidden', 'alert'],
@@ -273,8 +272,9 @@ describe('shared table and card feedback', () => {
     expect(screen.getByRole('alert').textContent).toBe(
       enUS.listFeedback.failed,
     );
+    expect(screen.getByRole('button')).toBeDisabled();
     expect(
-      screen.getByRole('button', { name: enUS.listFeedback.retrying }),
+      await screen.findByRole('button', { name: enUS.listFeedback.retrying }),
     ).toBeDisabled();
   });