@nocobase/app-template-default 1.0.0-beta.80 → 1.0.0-beta.82

package/tests/client/list-return-state.test.tsx

@@ -0,0 +1,202 @@
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import {
+  TestI18nProvider,
+  createTestI18nRuntime,
+} from '@nocobase/i18n/testing';
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import {
+  createMemoryRouter,
+  Link,
+  Outlet,
+  RouterProvider,
+  useLocation,
+  useSearchParams,
+} from 'react-router';
+import { describe, expect, it } from 'vitest';
+import { Breadcrumbs } from '../../client/components/breadcrumbs.js';
+import { BackButton } from '../../client/components/back-button.js';
+import { RouteTreeProvider } from '../../client/routing/route-context.js';
+import enUS from '../../client/locales/en-US.js';
+
+const runtime = await createTestI18nRuntime({
+  application: { namespace: '@nocobase/navigation-test', resources: enUS },
+  strict: false,
+});
+const route = (
+  path: string,
+  title: string,
+  children: AppClientRegisteredRoute[] = [],
+): AppClientRegisteredRoute => ({
+  id: path,
+  name: path,
+  path,
+  auth: 'required',
+  packageName: 'test',
+  source: 'application',
+  breadcrumb: { title },
+  componentLoader: async () => ({ default: () => null }),
+  children,
+});
+const routes = [
+  route('/orders', 'Orders', [
+    route('/orders/:id', 'Order', [route('/orders/:id/lines', 'Lines')]),
+  ]),
+  route('/other', 'Other', [route('/other/:id', 'Other detail')]),
+];
+const initial = '/orders?q=Acme&status=open&page=2';
+function List() {
+  const [query, setQuery] = useSearchParams();
+  const { pathname } = useLocation();
+  return (
+    <>
+      <input
+        aria-label='Search'
+        value={query.get('q') ?? ''}
+        onChange={(event) => {
+          const next = new URLSearchParams(query);
+          next.set('q', event.target.value);
+          next.delete('page');
+          setQuery(next);
+        }}
+      />
+      <output data-testid='page'>{query.get('page') ?? '1'}</output>
+      <output data-testid='record'>
+        {query.get('q') || 'All'}-{query.get('page') ?? '1'}
+      </output>
+      <Link to={`${pathname}/42?detailPage=7&q=child`}>Open detail</Link>
+      <button onClick={() => setQuery({})}>Clear</button>
+    </>
+  );
+}
+function Detail() {
+  return (
+    <>
+      <BackButton />
+      <Link to='lines?linePage=9'>Open lines</Link>
+    </>
+  );
+}
+function setup(url = initial) {
+  const router = createMemoryRouter(
+    [
+      {
+        element: (
+          <TestI18nProvider runtime={runtime}>
+            <RouteTreeProvider routes={routes}>
+              <Breadcrumbs />
+              <Outlet />
+            </RouteTreeProvider>
+          </TestI18nProvider>
+        ),
+        children: [
+          {
+            path: '/orders',
+            children: [
+              { index: true, element: <List /> },
+              {
+                path: ':id',
+                children: [
+                  { index: true, element: <Detail /> },
+                  { path: 'lines', element: <h1>Lines</h1> },
+                ],
+              },
+            ],
+          },
+          {
+            path: '/other',
+            children: [
+              { index: true, element: <List /> },
+              { path: ':id', element: <Detail /> },
+            ],
+          },
+        ],
+      },
+    ],
+    { initialEntries: [url] },
+  );
+  render(<RouterProvider router={router} />);
+  return router;
+}
+
+describe('returning to a list', () => {
+  it('restores the actual list query through breadcrumbs across repeated visits', async () => {
+    const router = setup();
+    for (let i = 0; i < 3; i++) {
+      await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+      expect(screen.getByRole('link', { name: 'Orders' })).toHaveAttribute(
+        'href',
+        initial,
+      );
+      await userEvent.click(screen.getByRole('link', { name: 'Orders' }));
+      expect(router.state.location.search).toBe('?q=Acme&status=open&page=2');
+      expect(screen.getByRole('textbox', { name: 'Search' })).toHaveValue(
+        'Acme',
+      );
+      expect(screen.getByTestId('page')).toHaveTextContent('2');
+      expect(screen.getByTestId('record')).toHaveTextContent('Acme-2');
+    }
+  });
+  it('restores list state through browser back and the standard BackButton', async () => {
+    const router = setup();
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    await act(() => router.navigate(-1));
+    expect(screen.getByTestId('record')).toHaveTextContent('Acme-2');
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    await userEvent.click(screen.getByRole('link', { name: 'Back' }));
+    expect(router.state.location.pathname).toBe('/orders');
+    expect(screen.getByTestId('record')).toHaveTextContent('Acme-2');
+  });
+  it('keeps each visited ancestor separate from a nested list query', async () => {
+    setup();
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    await userEvent.click(screen.getByRole('link', { name: 'Open lines' }));
+    expect(screen.getByRole('link', { name: 'Orders' })).toHaveAttribute(
+      'href',
+      initial,
+    );
+    // Middle levels appear in both the desktop trail and the collapsed menu.
+    expect(screen.getByRole('link', { name: 'Order' })).toHaveAttribute(
+      'href',
+      '/orders/42?detailPage=7&q=child',
+    );
+  });
+  it('does not revive cleared filters or leak one list into another', async () => {
+    const router = setup();
+    await userEvent.click(screen.getByRole('button', { name: 'Clear' }));
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    expect(screen.getByRole('link', { name: 'Orders' })).toHaveAttribute(
+      'href',
+      '/orders',
+    );
+    await act(() => router.navigate('/other?q=Beta&page=3'));
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    expect(screen.getByRole('link', { name: 'Other' })).toHaveAttribute(
+      'href',
+      '/other?q=Beta&page=3',
+    );
+    await act(() => router.navigate('/orders/42?detailPage=8'));
+    expect(screen.getByRole('link', { name: 'Orders' })).toHaveAttribute(
+      'href',
+      '/orders',
+    );
+  });
+  it('does not apply a deep-linked detail query to an unvisited ancestor', () => {
+    setup('/orders/42?detailPage=7');
+    expect(screen.getByRole('link', { name: 'Orders' })).toHaveAttribute(
+      'href',
+      '/orders',
+    );
+  });
+  it('uses the latest search after changing conditions and resetting the page', async () => {
+    setup();
+    await userEvent.clear(screen.getByRole('textbox', { name: 'Search' }));
+    await userEvent.type(
+      screen.getByRole('textbox', { name: 'Search' }),
+      'Beta',
+    );
+    await userEvent.click(screen.getByRole('link', { name: 'Open detail' }));
+    await userEvent.click(screen.getByRole('link', { name: 'Orders' }));
+    expect(screen.getByTestId('record')).toHaveTextContent('Beta-1');
+  });
+});

package/tests/client/role-return.test.tsx

@@ -0,0 +1,104 @@
+import { answerApi, renderWithApp } from '@nocobase/app-testing/client';
+import { apiClientToken, type ClientApplication } from '@nocobase/app-client';
+import {
+  AuthorizationClient,
+  authorizationClientToken,
+} from '@nocobase/app-plugin-authorization/client';
+import { screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Outlet, Routes, Route, useLocation } from 'react-router';
+import { expect, it, vi } from 'vitest';
+import RoleForm from '../../client/pages/settings/role-form.js';
+import enUS from '../../client/locales/en-US.js';
+import zhCN from '../../client/locales/zh-CN.js';
+
+const namespace = '@nocobase/role-return-test';
+function Parent() {
+  return <Outlet context={{ reload: () => undefined }} />;
+}
+function Location() {
+  const { pathname, search } = useLocation();
+  return (
+    <output data-testid='location'>
+      {pathname}
+      {search}
+    </output>
+  );
+}
+it.each(
+  ['/roles', '/administration/roles'].flatMap((parent) =>
+    ['back', 'cancel', 'save'].map((action) => ({ parent, action })),
+  ),
+)('returns to $parent on $action', async ({ parent, action }) => {
+  const calls = vi.fn(({ path }: { path: string }) => {
+    if (path === 'authorization/permissions')
+      return { data: { unrestricted: true, permissions: [] } };
+    if (path.endsWith('/options'))
+      return {
+        data: {
+          sections: [],
+          recordAccess: [],
+          subjectTypes: [],
+          collections: [],
+        },
+      };
+    return {
+      data: { key: 'sales', title: 'Sales', grants: [], revision: 'one' },
+    };
+  });
+  const result = await renderWithApp(
+    <>
+      <Routes>
+        <Route path={parent} element={<Parent />}>
+          <Route index element={<h1>Role list</h1>} />
+          <Route path=':key/edit' element={<RoleForm />} />
+        </Route>
+      </Routes>
+      <Location />
+    </>,
+    {
+      route: `${parent}/sales/edit?q=Sales&page=2`,
+      namespace,
+      namespaces: {
+        [namespace]: {
+          'en-US': async () => ({ default: enUS }),
+          'zh-CN': async () => ({ default: zhCN }),
+        },
+      },
+      services: (app: ClientApplication) =>
+        app.container.instance(
+          authorizationClientToken,
+          new AuthorizationClient(app.container.resolve(apiClientToken)),
+        ),
+      fetch: answerApi(calls),
+    },
+  );
+  expect(
+    await screen.findByRole('link', { name: enUS.settings.roles }),
+  ).toHaveAttribute('href', `${parent}?q=Sales&page=2`);
+  if (action === 'back') {
+    await userEvent.click(
+      screen.getByRole('link', { name: enUS.settings.roles }),
+    );
+  } else if (action === 'save') {
+    const name = await screen.findByRole('textbox', { name: /Role name/ });
+    await userEvent.type(name, ' updated');
+    await userEvent.click(
+      screen.getByRole('button', { name: 'Save', exact: true }),
+    );
+    await waitFor(() =>
+      expect(calls).toHaveBeenCalledWith(
+        expect.objectContaining({ method: 'PATCH' }),
+      ),
+    );
+  } else {
+    await userEvent.click(
+      await screen.findByRole('button', { name: 'Cancel' }),
+    );
+  }
+  await screen.findByRole('heading', { name: 'Role list' });
+  expect(screen.getByTestId('location')).toHaveTextContent(
+    `${parent}?q=Sales&page=2`,
+  );
+  result.unmount();
+});

package/tests/client/user-drawer.test.tsx

@@ -68,6 +68,7 @@ async function renderUsers(
   actions: string[] = [],
   initialRoles: Record<string, string[]> = {},
   requiredRole = false,
+  defaultRole = false,
 ) {
   let current = { ...original, roleScopes: initialRoles };
   let roleFailure = false;
@@ -105,7 +106,9 @@ async function renderUsers(
                     label: 'Application',
                     selection: 'multiple',
                     requiredOnCreate: requiredRole,
+                    ...(defaultRole ? { defaultValue: ['member'] } : {}),
                     options: [
+                      { value: 'member', label: 'Member' },
                       { value: 'sales', label: 'Sales team' },
                       { value: 'finance', label: 'Finance team' },
                       {
@@ -535,3 +538,48 @@ it('focuses and describes the required role dropdown when creating without a rol
     view.calls.mock.calls.filter(([call]) => call.method === 'POST'),
   ).toHaveLength(0);
 });
+
+it('uses Member only as a creation default and respects explicitly cleared selection', async () => {
+  const user = userEvent.setup();
+  const view = await renderUsers(
+    '/users',
+    '/create',
+    true,
+    true,
+    [],
+    {},
+    false,
+    true,
+  );
+  const roles = await screen.findByRole('combobox', {
+    name: 'Application',
+    exact: true,
+  });
+  expect(roles).toHaveTextContent('Member');
+  await user.click(roles);
+  await user.click(
+    await screen.findByRole('option', { name: 'Member', exact: true }),
+  );
+  await user.keyboard('{Escape}');
+  expect(roles).not.toHaveTextContent('Member');
+  expect(screen.getByText(enUS.settings.noRoleAccess)).toBeVisible();
+  await user.type(screen.getByRole('textbox', { name: 'Name *' }), 'Roleless');
+  await user.type(
+    screen.getByRole('textbox', { name: 'Email *' }),
+    'roleless@example.test',
+  );
+  await user.type(
+    screen.getByLabelText(`${enUS.settings.password} *`),
+    'Roleless-test-123!',
+  );
+  await user.click(screen.getByRole('button', { name: 'Create', exact: true }));
+  await waitFor(() =>
+    expect(view.calls).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'POST',
+        path: 'users',
+        json: expect.objectContaining({ roleScopes: { app: [] } }),
+      }),
+    ),
+  );
+});

package/tests/project/internal-packages.test.ts

@@ -0,0 +1,98 @@
+import { spawnSync } from 'node:child_process';
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { expect, it } from 'vitest';
+
+import packageMetadata from '../../package.json' with { type: 'json' };
+
+it('checks every internal package without selecting the root application and propagates a failed check', () => {
+  const root = mkdtempSync(path.join(os.tmpdir(), 'app-internal-checks-'));
+  try {
+    cpSync(
+      path.resolve(import.meta.dirname, '../../scripts'),
+      path.join(root, 'scripts'),
+      { recursive: true },
+    );
+    writeFileSync(
+      path.join(root, 'pnpm-workspace.yaml'),
+      "packages: ['packages/*']\nverifyDepsBeforeRun: false\n",
+    );
+    writeFileSync(
+      path.join(root, 'package.json'),
+      JSON.stringify({
+        name: 'fixture-app',
+        private: true,
+        scripts: {
+          'check:packages': packageMetadata.scripts['check:packages'],
+          check: 'node -e "process.exit(99)"',
+        },
+      }),
+    );
+    for (const name of ['first', 'second']) {
+      const directory = path.join(root, 'packages', name);
+      mkdirSync(directory, { recursive: true });
+      writeFileSync(
+        path.join(directory, 'package.json'),
+        JSON.stringify({
+          name: `fixture-${name}`,
+          private: true,
+          scripts: { check: 'node check.cjs' },
+        }),
+      );
+      writeFileSync(
+        path.join(directory, 'check.cjs'),
+        "require('node:fs').writeFileSync('checked', 'yes');\n",
+      );
+    }
+    const run = () =>
+      spawnSync('pnpm', ['check:packages'], {
+        cwd: root,
+        encoding: 'utf8',
+        timeout: 30_000,
+      });
+    expect(run().status).toBe(0);
+    for (const name of ['first', 'second']) {
+      expect(
+        readFileSync(path.join(root, 'packages', name, 'checked'), 'utf8'),
+      ).toBe('yes');
+    }
+    writeFileSync(
+      path.join(root, 'packages/second/check.cjs'),
+      'process.exit(7);\n',
+    );
+    expect(run().status).not.toBe(0);
+    rmSync(path.join(root, 'packages/first/checked'));
+    writeFileSync(
+      path.join(root, 'packages/second/package.json'),
+      JSON.stringify({ name: 'fixture-second', scripts: { check: '  ' } }),
+    );
+    const missing = run();
+    expect(missing.status).not.toBe(0);
+    expect(missing.stderr).toContain('packages/second');
+    expect(existsSync(path.join(root, 'packages/first/checked'))).toBe(false);
+    writeFileSync(
+      path.join(root, 'packages/second/package.json'),
+      JSON.stringify({ name: 'fixture-second' }),
+    );
+    expect(run().status).not.toBe(0);
+    // pnpm workspace exclusions apply to both the preflight and the script run.
+    writeFileSync(
+      path.join(root, 'pnpm-workspace.yaml'),
+      "packages: ['packages/*', '!packages/second']\nverifyDepsBeforeRun: false\n",
+    );
+    expect(run().status).toBe(0);
+    rmSync(path.join(root, 'packages'), { recursive: true });
+    expect(run().status).toBe(0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}, 60_000);

package/tests/project/tailwind-sources.test.ts

@@ -101,7 +101,7 @@ describe('tailwind content sources', () => {
     }
   });
 
-  it('scans canonical Registry source exposed by a plugin', () => {
+  it('ignores obsolete plugin-owned Registry recipes', () => {
     const store = mkdtempSync(path.join(tmpdir(), 'nb3-tailwind-registry-'));
     try {
       const registry = path.join(
@@ -124,7 +124,7 @@ describe('tailwind content sources', () => {
 
       const files = contentFilesIn(store);
 
-      expect(files).toContain(path.join(realpathSync(registry), 'demo.tsx'));
+      expect(files).toEqual([]);
     } finally {
       rmSync(store, { recursive: true, force: true });
     }

package/tests/server/authorization-assignment-safety.test.ts

@@ -11,14 +11,7 @@ type Assignment = {
 function unexpectedGlobalAssignments(
   assignments: readonly Assignment[],
 ): Assignment[] {
-  return assignments.filter(
-    (assignment) =>
-      assignment.subjectId === '*' &&
-      !(
-        assignment.subjectType === 'authenticated' &&
-        assignment.permissionSetKey === 'member'
-      ),
-  );
+  return assignments.filter((assignment) => assignment.subjectId === '*');
 }
 
 const test = createAppTest({
@@ -76,5 +69,13 @@ it('detects wildcard recipients regardless of the role name, while preserving ex
       global,
       { ...global, subjectType: 'everyone' },
     ]),
-  ).toEqual([global, { ...global, subjectType: 'everyone' }]);
+  ).toEqual([
+    {
+      subjectType: 'authenticated',
+      subjectId: '*',
+      permissionSetKey: 'member',
+    },
+    global,
+    { ...global, subjectType: 'everyone' },
+  ]);
 });