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

package/tests/client/settings-home.test.tsx

@@ -0,0 +1,110 @@
+import packageMetadata from '../../package.json' with { type: 'json' };
+import { renderAuthenticatedClient } from '../helpers/authenticated-client.js';
+import { resolveAppClientContributions } from '@nocobase/app-client/plugins';
+import { screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { ReactNode } from 'react';
+import { Route, Routes, useLocation } from 'react-router';
+import { expect, it } from 'vitest';
+import { Breadcrumbs } from '../../client/components/breadcrumbs.js';
+import SettingsHomePage from '../../client/pages/settings/settings-home.js';
+import settingsRoutes from '../../client/pages/settings/routes.js';
+import shellRoutes from '../../client/pages/settings/shell-routes.js';
+import { RouteTreeProvider } from '../../client/routing/route-context.js';
+import { useRouteNavigation } from '../../client/routing/route-navigation.js';
+
+const { routes } = resolveAppClientContributions([
+  {
+    packageName: packageMetadata.name,
+    source: 'application',
+    routes: [shellRoutes, settingsRoutes],
+  },
+]);
+
+function Shell({ children }: { children: ReactNode }) {
+  const { denied, loading } = useRouteNavigation(routes);
+  return (
+    <RouteTreeProvider routes={routes} access={{ denied, loading }}>
+      <Breadcrumbs denied={denied} />
+      {children}
+    </RouteTreeProvider>
+  );
+}
+
+function Where() {
+  return <output aria-label='Route'>{useLocation().pathname}</output>;
+}
+
+function mount(
+  options: Parameters<typeof renderAuthenticatedClient>[1] = {},
+  route = '/settings',
+) {
+  return renderAuthenticatedClient(
+    <Shell>
+      <Routes>
+        <Route path='/settings' element={<SettingsHomePage />} />
+        <Route path='*' element={<Where />} />
+      </Routes>
+    </Shell>,
+    { route, ...options },
+  );
+}
+
+it('groups the modules an administrator may open into categories of cards that open by keyboard', async () => {
+  const user = userEvent.setup();
+  await mount();
+  const account = await screen.findByRole('region', {
+    name: 'Accounts and permissions',
+  });
+  const cards = within(account).getAllByRole('link');
+  expect(cards.map((card) => card.textContent)).toEqual([
+    'UsersManage accounts, access and active sessions.',
+    'Permission managementSet what each role can open and do, and the data it can see.',
+  ]);
+  expect(cards[0]).toHaveAttribute('href', '/main/settings/users');
+  expect(cards[1]).toHaveAttribute('href', '/main/settings/roles');
+  // Categories without a module this viewer may open are not shown.
+  expect(screen.getAllByRole('region')).toHaveLength(1);
+  cards[1].focus();
+  await user.keyboard('{Enter}');
+  await waitFor(() =>
+    expect(screen.getByRole('status', { name: 'Route' })).toHaveTextContent(
+      '/settings/roles',
+    ),
+  );
+});
+
+it('shows a restricted viewer only what they may open, opening a tabbed module on its readable view', async () => {
+  await mount({
+    member: true,
+    grants: [
+      {
+        resource: { type: 'settings', id: 'authorization.default-access' },
+        actions: [{ action: 'read' }],
+      },
+    ],
+  });
+  const account = await screen.findByRole('region', {
+    name: 'Accounts and permissions',
+  });
+  // Categories without a module this viewer may open are not shown.
+  expect(screen.getAllByRole('region')).toHaveLength(1);
+  const cards = within(account).getAllByRole('link');
+  expect(cards).toHaveLength(1);
+  expect(cards[0]).toHaveAttribute('href', '/main/settings/default-access');
+});
+
+it('explains when there is nothing to manage', async () => {
+  await mount({ member: true, locale: 'zh-CN' });
+  expect(await screen.findByText('暂时没有你可以管理的设置。')).toBeVisible();
+  expect(screen.getByRole('heading', { name: '系统设置' })).toBeVisible();
+});
+
+it('links the System settings breadcrumb back to the home from a module view', async () => {
+  await mount({}, '/settings/roles');
+  const trail = await screen.findByRole('navigation', { name: 'Breadcrumb' });
+  expect(
+    within(trail).getByRole('link', { name: 'System settings' }),
+  ).toHaveAttribute('href', '/main/settings');
+  expect(within(trail).getByText('Roles and permissions')).toBeVisible();
+});

package/tests/client/settings-navigation.test.ts

@@ -0,0 +1,230 @@
+import {
+  defineAppRoutes,
+  resolveAppClientContributions,
+  type AppClientRegisteredRoute,
+} from '@nocobase/app-client/plugins';
+import { describe, expect, it } from 'vitest';
+import foundation from '@nocobase/app-plugin-foundation/client/routes';
+import settings from '../../client/pages/settings/routes.js';
+import shell from '../../client/pages/settings/shell-routes.js';
+import { createApplicationRoutes } from '../../client/routes.js';
+import {
+  buildRouteNavigation,
+  buildSettingsCatalog,
+  filterRouteTree,
+  selectedNavigationId,
+  routeKey,
+} from '../../client/routing/route-navigation.js';
+
+const componentLoader = async () => ({ default: () => null });
+const app = '@nocobase/app-template-default';
+
+function resolve(...extra: ReturnType<typeof defineAppRoutes>[]) {
+  return resolveAppClientContributions([
+    {
+      packageName: app,
+      source: 'application',
+      routes: [shell, settings, ...extra],
+    },
+  ]).routes;
+}
+
+function find(
+  routes: readonly AppClientRegisteredRoute[],
+  name: string,
+): AppClientRegisteredRoute {
+  for (const route of routes) {
+    if (route.name === name) return route;
+    const nested = route.children && find(route.children, name);
+    if (nested) return nested;
+  }
+  return undefined as unknown as AppClientRegisteredRoute;
+}
+
+const catalog = (
+  routes: readonly AppClientRegisteredRoute[],
+  denied = new Set<string>(),
+) =>
+  buildSettingsCatalog(routes, denied).map((category) => [
+    category.route.name,
+    category.modules.map((module) => [module.route.name, module.target.path]),
+  ]);
+
+describe('System settings navigation', () => {
+  it('keeps the existing URLs and authorization of the settings pages', () => {
+    const routes = resolve();
+    expect(
+      [
+        'settingsHome',
+        'settingsUsers',
+        'settingsRoles',
+        'settingsDefaultAccess',
+      ].map((name) => {
+        const route = find(routes, name);
+        return [name, route.path, route.authz];
+      }),
+    ).toEqual([
+      ['settingsHome', '/settings', 'skip'],
+      [
+        'settingsUsers',
+        '/settings/users',
+        { resource: { type: 'user', id: '*' }, action: 'read' },
+      ],
+      [
+        'settingsRoles',
+        '/settings/roles',
+        {
+          resource: { type: 'settings', id: 'authorization.permission-sets' },
+          action: 'read',
+        },
+      ],
+      [
+        'settingsDefaultAccess',
+        '/settings/default-access',
+        {
+          resource: { type: 'settings', id: 'authorization.default-access' },
+          action: 'read',
+        },
+      ],
+    ]);
+    expect(find(routes, 'settingsUsers').id).toBe(`${app}:settingsUsers`);
+  });
+
+  it('shows one sidebar entry that opens the home and stays selected on every settings page', () => {
+    const routes = resolve();
+    const menu = buildRouteNavigation(routes, new Set());
+    expect(menu.map(({ route }) => [route.name, route.path])).toEqual([
+      ['settingsHome', '/settings'],
+    ]);
+    expect(menu[0].children).toEqual([]);
+    expect(menu[0].route.navigation?.title).toBe('settings.title');
+    const entry = routeKey(menu[0].route);
+    for (const path of [
+      '/settings',
+      '/settings/users',
+      '/settings/users/create',
+      '/settings/roles/member/edit',
+      '/settings/default-access',
+    ])
+      expect(selectedNavigationId(routes, path)).toBe(entry);
+  });
+
+  it('groups modules into categories, opens a tabbed module on its first readable tab and hides empty categories', () => {
+    const routes = resolve();
+    expect(catalog(routes)).toEqual([
+      [
+        'settingsAccount',
+        [
+          ['settingsUsers', '/settings/users'],
+          ['permissionManagement', '/settings/roles'],
+        ],
+      ],
+    ]);
+    const roles = find(routes, 'settingsRoles');
+    expect(catalog(routes, new Set([routeKey(roles)]))).toEqual([
+      [
+        'settingsAccount',
+        [
+          ['settingsUsers', '/settings/users'],
+          ['permissionManagement', '/settings/default-access'],
+        ],
+      ],
+    ]);
+    const denied = new Set(
+      ['settingsUsers', 'settingsRoles', 'settingsDefaultAccess'].map((name) =>
+        routeKey(find(routes, name)),
+      ),
+    );
+    expect(catalog(routes, denied)).toEqual([]);
+    // Without a module to open, the sidebar entry disappears too.
+    expect(buildRouteNavigation(routes, denied)).toEqual([]);
+  });
+
+  it('adds a later module with several views to its category without another sidebar entry', () => {
+    const routes = resolve(
+      defineAppRoutes([
+        {
+          parent: 'settingsSystem',
+          name: 'notificationManagement',
+          navigation: {
+            title: 'Notifications',
+            description: 'Channels and delivery records.',
+          },
+          breadcrumb: { title: 'Notifications' },
+          children: [
+            {
+              name: 'notificationLogs',
+              path: '/notifications/logs',
+              authz: {
+                resource: { type: 'page', id: 'notification.logs' },
+                action: 'access',
+              },
+              navigation: { title: 'Delivery logs' },
+              componentLoader,
+            },
+          ],
+        },
+      ]),
+    );
+    expect(find(routes, 'notificationLogs').path).toBe(
+      '/settings/notifications/logs',
+    );
+    expect(catalog(routes).at(-1)).toEqual([
+      'settingsSystem',
+      [['notificationManagement', '/settings/notifications/logs']],
+    ]);
+    expect(buildRouteNavigation(routes, new Set())).toHaveLength(1);
+    expect(selectedNavigationId(routes, '/settings/notifications/logs')).toBe(
+      routeKey(buildRouteNavigation(routes, new Set())[0].route),
+    );
+  });
+
+  it('places a plugin module registered outside the categories under System', () => {
+    const routes = resolveAppClientContributions([
+      { packageName: app, source: 'application', routes: [shell] },
+      {
+        packageName: '@nocobase/app-plugin-foundation',
+        source: 'plugin',
+        routes: foundation,
+      },
+    ]).routes;
+    // The bare shell: only App Foundation, which only an unrestricted administrator may open.
+    const menu = buildRouteNavigation(routes, new Set());
+    expect(menu.map(({ route }) => route.name)).toEqual(['settingsHome']);
+    expect(catalog(routes)).toEqual([
+      ['settingsSystem', [['foundation', '/foundation']]],
+    ]);
+    // The signed-in shell receives the tree filtered to its pages; empty categories keep their titles there.
+    const signedIn = filterRouteTree(
+      routes,
+      (route) => route.auth === 'required',
+    );
+    expect(catalog(signedIn)).toEqual([
+      ['settingsSystem', [['foundation', '/foundation']]],
+    ]);
+    const page = find(routes, 'foundation');
+    expect(page.navigation?.description).toBe('nav.foundationDescription');
+    expect(buildRouteNavigation(routes, new Set([routeKey(page)]))).toEqual([]);
+  });
+
+  it('shows the notification template view as a System card once an invitation mailer is configured', () => {
+    const routes = resolveAppClientContributions([
+      {
+        packageName: app,
+        source: 'application',
+        routes: createApplicationRoutes({
+          notificationTemplates: { invitationConfigured: true },
+        }),
+      },
+    ]).routes;
+    expect(catalog(routes)).toEqual([
+      [
+        'settingsSystem',
+        [['notificationManagement', '/settings/notifications/templates']],
+      ],
+    ]);
+    expect(
+      buildRouteNavigation(routes, new Set()).map(({ route }) => route.name),
+    ).toEqual(['home', 'settingsHome']);
+  });
+});

package/tests/server/notification-templates.test.ts

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import {
+  signIn,
+  DEFAULT_ADMIN_CREDENTIALS,
+} from '@nocobase/app-plugin-authentication/testing';
+import { createAppTest } from '@nocobase/app-testing/server';
+import { describe, expect } from 'vitest';
+import { createStandaloneServer } from '../../server/standalone.js';
+
+const common = {
+  createServer: createStandaloneServer,
+  scope: 'test' as const,
+  config: {
+    app: { publicOrigin: 'http://localhost' },
+    spa: {
+      indexPath: fileURLToPath(new URL('../../index.html', import.meta.url)),
+    },
+    auth: {
+      secret: 'notification-template-test-secret-at-least-32-characters',
+    },
+  },
+};
+describe('bare Default', () => {
+  const test = createAppTest(common);
+  test('keeps the bare Default navigation disabled without an invitation transport', async ({
+    app,
+  }) => {
+    expect(
+      app.config.get('client.notificationTemplates.invitationConfigured'),
+    ).toBe(false);
+  });
+});
+describe('configured Default', () => {
+  const test = createAppTest({
+    ...common,
+    config: {
+      ...common.config,
+      mailers: {
+        default: 'system',
+        system: {
+          provider: 'smtp',
+          host: '127.0.0.1',
+          port: 9,
+          auth: { user: 'synthetic', pass: 'synthetic-private-password' },
+        },
+      },
+    },
+  });
+
+  test('boots the real Default invitation directory and protects all three endpoints', async ({
+    testApp,
+    app,
+    request,
+  }) => {
+    expect(
+      app.config.get('client.notificationTemplates.invitationConfigured'),
+    ).toBe(true);
+    const page = await testApp.fetch(
+      new Request(`http://localhost${testApp.publicBasePath}/`),
+    );
+    expect(page.status).toBe(200);
+    const html = await page.text();
+    expect(html).toContain('"invitationConfigured":true');
+    expect(html).not.toContain('synthetic-private-password');
+    const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);
+    expect((await request('/notifications/templates')).status).toBe(401);
+    const list = await admin.fetch('/notifications/templates');
+    expect(list.status).toBe(200);
+    const body = await list.json();
+    expect(JSON.stringify(body)).not.toContain('synthetic-private-password');
+    expect(body.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'users.invitation',
+          channels: [
+            { name: 'system', type: 'email', configured: true, enabled: true },
+          ],
+        }),
+      ]),
+    );
+    const detail = await admin.fetch(
+      '/notifications/templates/users.invitation',
+    );
+    expect(detail.status).toBe(200);
+    const logsBefore = await (await admin.fetch('/notifications/logs')).json();
+    const preview = await admin.fetch(
+      '/notifications/templates/users.invitation/preview',
+      {
+        method: 'POST',
+        headers: {
+          origin: 'http://localhost',
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({ locale: 'en-US' }),
+      },
+    );
+    expect(preview.status).toBe(200);
+    expect(JSON.stringify(await preview.json())).toContain('example.invalid');
+    expect(await (await admin.fetch('/notifications/logs')).json()).toEqual(
+      logsBefore,
+    );
+    const member = {
+      username: 'templateviewer',
+      email: 'templateviewer@example.invalid',
+      password: 'Synthetic-template-viewer-943!',
+    };
+    const created = await admin.fetch('/users', {
+      method: 'POST',
+      headers: {
+        origin: 'http://localhost',
+        'content-type': 'application/json',
+        'Idempotency-Key': `${Date.now()}.${randomUUID()}`,
+      },
+      body: JSON.stringify({
+        ...member,
+        name: 'Synthetic restricted viewer',
+        roleScopes: {},
+      }),
+    });
+    expect(created.status).toBe(201);
+    const restricted = await signIn(testApp, member);
+    for (const endpoint of [
+      '',
+      '/users.invitation',
+      '/users.invitation/preview',
+    ]) {
+      const response = await restricted.fetch(
+        `/notifications/templates${endpoint}`,
+        endpoint.endsWith('/preview')
+          ? {
+              method: 'POST',
+              headers: {
+                origin: 'http://localhost',
+                'content-type': 'application/json',
+              },
+              body: JSON.stringify({ locale: 'en-US' }),
+            }
+          : undefined,
+      );
+      expect(response.status).toBe(403);
+    }
+  });
+});

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

@@ -1,64 +0,0 @@
-import { resolveAppClientContributions } from '@nocobase/app-client/plugins';
-import { expect, it } from 'vitest';
-import settings from '../../client/pages/settings/routes.js';
-import {
-  buildRouteNavigation,
-  selectedNavigationId,
-  routeKey,
-} from '../../client/routing/route-navigation.js';
-it('groups existing permission pages without changing their URLs or authorization and hides inaccessible children', () => {
-  const { routes } = resolveAppClientContributions([
-    { packageName: 'test', source: 'application', routes: [settings] },
-  ]);
-  const group = routes[0].children!.find(
-    (route) => route.name === 'permissionManagement',
-  )!;
-  expect(group.componentLoader).toBeUndefined();
-  expect(
-    group.children!.map((route) => [route.name, route.path, route.authz]),
-  ).toEqual([
-    [
-      'settingsRoles',
-      '/settings/roles',
-      {
-        resource: { type: 'settings', id: 'authorization.permission-sets' },
-        action: 'read',
-      },
-    ],
-    [
-      'settingsDefaultAccess',
-      '/settings/default-access',
-      {
-        resource: { type: 'settings', id: 'authorization.default-access' },
-        action: 'read',
-      },
-    ],
-  ]);
-  const visible = buildRouteNavigation(routes, new Set())[0].children.find(
-    ({ route }) => route.name === 'permissionManagement',
-  )!;
-  expect(visible.children).toEqual([]);
-  expect(visible.route.path).toBe('/settings/roles');
-  expect(visible.route.navigation?.title).toBe('settings.permissionManagement');
-  expect(selectedNavigationId(routes, '/settings/roles/member/edit')).toBe(
-    routeKey(visible.route),
-  );
-  expect(selectedNavigationId(routes, '/settings/default-access')).toBe(
-    routeKey(visible.route),
-  );
-  const denied = new Set([routeKey(group.children![0])]);
-  const onlyDefault = buildRouteNavigation(routes, denied)[0].children.find(
-    ({ route }) => route.name === 'permissionManagement',
-  )!;
-  expect(onlyDefault.children).toEqual([]);
-  expect(onlyDefault.route.path).toBe('/settings/default-access');
-  expect(selectedNavigationId(routes, '/settings/default-access', denied)).toBe(
-    routeKey(onlyDefault.route),
-  );
-  denied.add(routeKey(group.children![1]));
-  expect(
-    buildRouteNavigation(routes, denied)[0].children.map(
-      ({ route }) => route.name,
-    ),
-  ).toEqual(['settingsUsers']);
-});