@nocobase/app-template-default 1.0.0-beta.67 → 1.0.0-beta.69

package/tests/logic/scrollbar.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import { revealScrollbarsWhileScrolling } from '../../client/lib/scrollbar';
+
+describe('revealScrollbarsWhileScrolling', () => {
+  beforeAll(() => revealScrollbarsWhileScrolling());
+  afterEach(() => vi.useRealTimers());
+
+  function scroll(target: EventTarget) {
+    target.dispatchEvent(new Event('scroll'));
+  }
+
+  it('marks a scrolling element until it has been still for a moment', () => {
+    vi.useFakeTimers();
+    const list = document.createElement('div');
+    document.body.append(list);
+    scroll(list);
+    expect(list).toHaveAttribute('data-scrolling');
+    vi.advanceTimersByTime(799);
+    expect(list).toHaveAttribute('data-scrolling');
+    vi.advanceTimersByTime(1);
+    expect(list).not.toHaveAttribute('data-scrolling');
+    list.remove();
+  });
+
+  it('keeps the mark while scrolling goes on', () => {
+    vi.useFakeTimers();
+    const list = document.createElement('div');
+    document.body.append(list);
+    scroll(list);
+    vi.advanceTimersByTime(600);
+    scroll(list);
+    vi.advanceTimersByTime(600);
+    expect(list).toHaveAttribute('data-scrolling');
+    vi.advanceTimersByTime(200);
+    expect(list).not.toHaveAttribute('data-scrolling');
+    list.remove();
+  });
+
+  it('marks the page root when the page itself scrolls', () => {
+    vi.useFakeTimers();
+    scroll(document);
+    expect(
+      document.scrollingElement ?? document.documentElement,
+    ).toHaveAttribute('data-scrolling');
+    vi.advanceTimersByTime(800);
+    expect(
+      document.scrollingElement ?? document.documentElement,
+    ).not.toHaveAttribute('data-scrolling');
+  });
+});
+
+describe('revealScrollbarsWhileScrolling near an edge', () => {
+  function scroller(): HTMLDivElement {
+    const element = document.createElement('div');
+    element.style.overflowY = 'auto';
+    Object.defineProperty(element, 'scrollHeight', { value: 500 });
+    Object.defineProperty(element, 'clientHeight', { value: 100 });
+    element.getBoundingClientRect = () =>
+      ({ left: 0, top: 0, right: 200, bottom: 100 }) as DOMRect;
+    document.body.append(element);
+    return element;
+  }
+
+  function move(target: Element, clientX: number) {
+    const event = new MouseEvent('pointermove', {
+      bubbles: true,
+      clientX,
+      clientY: 50,
+    });
+    Object.defineProperty(event, 'pointerType', { value: 'mouse' });
+    target.dispatchEvent(event);
+  }
+
+  it('shows the bar while the mouse is near the edge it runs along', () => {
+    vi.useFakeTimers();
+    const list = scroller();
+    move(list, 100);
+    vi.advanceTimersByTime(20);
+    expect(list).not.toHaveAttribute('data-scrolling');
+    move(list, 195);
+    vi.advanceTimersByTime(20);
+    expect(list).toHaveAttribute('data-scrolling');
+    vi.advanceTimersByTime(800);
+    expect(list).not.toHaveAttribute('data-scrolling');
+    list.remove();
+  });
+});

package/tests/logic/session-preparation.test.tsx

@@ -0,0 +1,223 @@
+import {
+  ClientApplicationContext,
+  realtimeClientToken,
+  type ClientApplication,
+} from '@nocobase/app-client';
+import {
+  AuthenticationProvider,
+  authenticationClientToken,
+  useAuthentication,
+} from '@nocobase/app-plugin-authentication/client';
+import {
+  AuthorizationClient,
+  authorizationClientToken,
+} from '@nocobase/app-plugin-authorization/client';
+import { reactProviders } from '@nocobase/app-plugin-authorization/client/react-providers';
+import { ServiceContainer } from '@nocobase/service-provider';
+import {
+  TestI18nProvider,
+  createTestI18nRuntime,
+} from '@nocobase/i18n/testing';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { useEffect } from 'react';
+import { MemoryRouter, Outlet } from 'react-router';
+import { afterEach, expect, it, vi } from 'vitest';
+import { AppRouter } from '../../client/routing/app-router.js';
+import {
+  Dialog,
+  DialogContent,
+  DialogTitle,
+  DialogDescription,
+} from '../../client/components/ui/dialog.js';
+import enUS from '../../client/locales/en-US.js';
+
+const AuthorizationProvider = reactProviders[0].component;
+vi.mock('../../client/layouts/app-layout.js', () => ({
+  AppLayout: () => <Outlet />,
+}));
+vi.mock('../../client/routing/standalone-page-layout.js', () => ({
+  StandalonePageLayout: () => <Outlet />,
+}));
+const runtime = await createTestI18nRuntime({
+  application: { namespace: 'test', resources: enUS },
+});
+afterEach(() => vi.useRealTimers());
+
+async function setup() {
+  const allowed = {
+    data: {
+      unrestricted: false,
+      permissions: [
+        { resource: { type: 'page', id: 'probe' }, actions: ['access'] },
+      ],
+    },
+  };
+  const request = vi.fn().mockResolvedValue(allowed);
+  const authz = new AuthorizationClient({ request } as never);
+  const services = new ServiceContainer();
+  const listeners = new Set<() => void>();
+  const realtime = {
+    active: true,
+    reconnect: vi.fn(),
+    onOpen: (listener: () => void) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+  const signOut = vi.fn().mockResolvedValue({ error: { message: 'Offline' } });
+  let session: unknown = { user: { id: 'user' }, session: { id: 'session' } };
+  const getSession = vi.fn(async () => ({ data: session }));
+  services.instance(authenticationClientToken, {
+    getSession,
+    signOut,
+  } as never);
+  services.instance(realtimeClientToken, realtime as never);
+  services.instance(authorizationClientToken, authz);
+  const mounted = vi.fn();
+  const cleaned = vi.fn();
+  const accepted = vi.fn();
+  const old = Promise.withResolvers<void>();
+  function Page() {
+    useEffect(() => {
+      let active = true;
+      mounted();
+      void old.promise.then(() => {
+        if (active) accepted();
+      });
+      return () => {
+        active = false;
+        cleaned();
+      };
+    }, []);
+    return (
+      <Dialog open>
+        <DialogContent>
+          <DialogTitle>Protected dialog</DialogTitle>
+          <DialogDescription>Protected content</DialogDescription>
+        </DialogContent>
+      </Dialog>
+    );
+  }
+  let refresh!: () => Promise<void>;
+  function Capture() {
+    refresh = useAuthentication().refresh;
+    return null;
+  }
+  const route = {
+    id: 'probe',
+    name: 'probe',
+    path: '/',
+    auth: 'required',
+    authz: { resource: { type: 'page', id: 'probe' }, action: 'access' },
+    packageName: 'test',
+    source: 'application',
+    componentLoader: async () => ({ default: Page }),
+  } as const;
+  render(
+    <TestI18nProvider runtime={runtime}>
+      <ClientApplicationContext.Provider
+        value={{ services } as unknown as ClientApplication}
+      >
+        <AuthenticationProvider>
+          <Capture />
+          <AuthorizationProvider>
+            <MemoryRouter>
+              <AppRouter
+                clientRoutes={[
+                  route,
+                  {
+                    id: 'login',
+                    name: 'login',
+                    path: '/login',
+                    auth: 'guest',
+                    authz: 'skip',
+                    source: 'application',
+                    packageName: 'test',
+                    componentLoader: async () => ({
+                      default: () => <p>Login route</p>,
+                    }),
+                  },
+                ]}
+              />
+            </MemoryRouter>
+          </AuthorizationProvider>
+        </AuthenticationProvider>
+      </ClientApplicationContext.Provider>
+    </TestI18nProvider>,
+  );
+  await act(async () => {});
+  // Register after preparation to prove ordering does not depend on effects.
+  listeners.add(() => authz.invalidate());
+  return {
+    allowed,
+    request,
+    authz,
+    realtime,
+    signOut,
+    getSession,
+    mounted,
+    cleaned,
+    accepted,
+    old,
+    open: async () => {
+      await act(async () => {
+        for (const listener of listeners) listener();
+      });
+    },
+    logout: async () => {
+      session = null;
+      await act(async () => refresh());
+    },
+  };
+}
+
+it('mounts only after the initial handshake and preserves runtime fail-closed portal cleanup', async () => {
+  const probe = await setup();
+  expect(probe.mounted).not.toHaveBeenCalled();
+  expect(probe.request).not.toHaveBeenCalled();
+  await probe.open();
+  await screen.findByText('Protected dialog');
+  expect(probe.mounted).toHaveBeenCalledOnce();
+  expect(probe.request).toHaveBeenCalledOnce();
+  const next = Promise.withResolvers<typeof probe.allowed>();
+  probe.request.mockReturnValueOnce(next.promise);
+  await probe.open();
+  expect(screen.queryByRole('dialog')).toBeNull();
+  expect(probe.cleaned).toHaveBeenCalledOnce();
+  await act(async () => probe.old.resolve());
+  expect(probe.accepted).not.toHaveBeenCalled();
+  await act(async () =>
+    next.resolve({ data: { unrestricted: false, permissions: [] } }),
+  );
+  expect(screen.queryByRole('dialog')).toBeNull();
+  expect(await screen.findByText('Access denied')).toBeVisible();
+});
+
+it('keeps a timed-out session closed, supports retry, and reports sign-out failure', async () => {
+  vi.useFakeTimers();
+  const probe = await setup();
+  await act(async () => vi.advanceTimersByTime(10_000));
+  expect(screen.getByText('Unable to connect')).toBeVisible();
+  fireEvent.click(screen.getByRole('button', { name: 'Sign out' }));
+  await act(async () => {});
+  expect(screen.getByRole('alert')).toHaveTextContent('Unable to sign out');
+  fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
+  expect(probe.realtime.reconnect).toHaveBeenCalledTimes(2);
+  expect(screen.queryByText('Unable to connect')).toBeNull();
+  await probe.open();
+  expect(probe.mounted).toHaveBeenCalledOnce();
+});
+
+it('can sign out of a failed initialization without a working realtime connection', async () => {
+  vi.useFakeTimers();
+  const probe = await setup();
+  await act(async () => vi.advanceTimersByTime(10_000));
+  probe.signOut.mockResolvedValueOnce({});
+  probe.getSession.mockResolvedValueOnce({ data: null });
+  fireEvent.click(screen.getByRole('button', { name: 'Sign out' }));
+  await act(async () => {});
+  expect(screen.getByText('Login route')).toBeVisible();
+  expect(probe.mounted).not.toHaveBeenCalled();
+});

package/tests/logic/settings-permissions.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import {
+  setPermission,
+  setPermissions,
+  permissionSections,
+  setScope,
+  type CatalogResource,
+} from '../../client/pages/settings/permissions-model.js';
+const resource: CatalogResource = {
+  type: 'composite',
+  id: 'orders',
+  title: 'Orders',
+  actions: [{ name: 'edit', title: 'Edit' }],
+  dataScopes: {
+    edit: [
+      {
+        key: 'records',
+        title: 'Records',
+        collection: 'orders',
+        fields: [],
+        recordAccess: ['mine', 'all'],
+        defaultValue: 'mine',
+      },
+    ],
+  },
+};
+describe('settings permission drafts', () => {
+  it('adds only the explicit action at its registered default and keeps unrelated policies intact', () => {
+    const untouched = {
+      resource: { type: 'settings', id: 'notification' },
+      actions: [{ action: 'read', policy: { type: 'custom', region: 'east' } }],
+    };
+    const original = [untouched];
+    const next = setPermission(original, resource, 'edit', true);
+    expect(next).toContainEqual(untouched);
+    expect(next[1]?.actions).toEqual([
+      {
+        action: 'edit',
+        policy: { type: 'composite', scopes: { records: 'mine' } },
+      },
+    ]);
+    expect(original).toEqual([untouched]);
+    expect(setPermission(next, resource, 'edit', false)).toEqual([untouched]);
+  });
+  it('changes one scope without losing a different scope or custom grant', () => {
+    const original = [
+      {
+        resource: { type: 'composite', id: 'orders' },
+        actions: [
+          {
+            action: 'edit',
+            policy: {
+              type: 'composite',
+              scopes: {
+                records: 'mine',
+                attachments: { selected: ['file-1'] },
+              },
+            },
+          },
+          { action: 'approve' },
+        ],
+      },
+    ];
+    const next = setScope(
+      original,
+      JSON.stringify(['composite', 'orders', 'edit', 'records']),
+      'all',
+    );
+    expect(next[0]?.actions[0]?.policy).toMatchObject({
+      scopes: { records: 'all', attachments: { selected: ['file-1'] } },
+    });
+    expect(next[0]?.actions[1]).toEqual({ action: 'approve' });
+    expect(original[0]?.actions[0]?.policy.scopes.records).toBe('mine');
+  });
+});
+
+it('keeps action scopes inline and folds a visible batch without resetting existing policies', () => {
+  const catalog = {
+    sections: [
+      {
+        name: 'business',
+        title: 'Business',
+        subsections: [
+          {
+            name: 'orders',
+            title: 'Orders',
+            resources: [
+              {
+                ...resource,
+                actions: [
+                  ...resource.actions,
+                  { name: 'export', title: 'Export' },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    recordAccess: [
+      { key: 'mine', title: 'Mine' },
+      { key: 'all', title: 'All' },
+    ],
+  } as unknown as Parameters<typeof permissionSections>[0];
+  const unrelated = {
+    resource: { type: 'unknown', id: 'legacy' },
+    actions: [{ action: 'custom', policy: { type: 'custom', keep: true } }],
+  };
+  const original = [...setPermission([], resource, 'edit', true), unrelated];
+  const before = JSON.stringify(original);
+  const changed = setPermissions(original, catalog, [
+    { id: JSON.stringify(['composite', 'orders', 'export']), enabled: true },
+    { id: JSON.stringify(['composite', 'orders', 'edit']), enabled: true },
+    {
+      id: JSON.stringify(['composite', 'orders', 'notRegistered']),
+      enabled: true,
+    },
+  ]);
+  expect(changed).toContainEqual(unrelated);
+  expect(changed[0]?.actions).toEqual([
+    ...original[0]!.actions,
+    { action: 'export' },
+  ]);
+  expect(JSON.stringify(original)).toBe(before);
+  const result = permissionSections(catalog, changed, (value) =>
+    typeof value === 'string' ? value : value.key,
+  );
+  expect(result[0]?.groups[0]?.rows).toHaveLength(2);
+  expect(result[0]?.groups[0]?.rows[0]?.scopes?.[0]).toMatchObject({
+    label: 'Records',
+    level: 'mine',
+    id: JSON.stringify(['composite', 'orders', 'edit', 'records']),
+  });
+});
+
+it('replaces a raw collection scope caption with localized data-range text', () => {
+  const scopedResource = {
+    ...resource,
+    dataScopes: {
+      edit: [{ ...resource.dataScopes!.edit![0]!, title: 'orders' }],
+    },
+  };
+  const catalog = {
+    sections: [
+      {
+        name: 's',
+        title: 'Business',
+        subsections: [
+          { name: 'orders', title: 'Orders', resources: [scopedResource] },
+        ],
+      },
+    ],
+    recordAccess: [{ key: 'mine', title: 'Mine' }],
+  } as unknown as Parameters<typeof permissionSections>[0];
+  const result = permissionSections(
+    catalog,
+    setPermission([], scopedResource, 'edit', true),
+    (value) =>
+      typeof value === 'string'
+        ? value
+        : value.key === 'settings.recordScope'
+          ? 'Record scope'
+          : value.key,
+  );
+  expect(result[0]?.groups[0]?.rows[0]?.scopes?.[0]?.label).toBe(
+    'Record scope',
+  );
+});

package/tests/logic/theme-tokens.test.ts

@@ -40,6 +40,7 @@ const colors = [
   'muted-foreground',
   'accent',
   'accent-foreground',
+  'hover',
   'destructive',
   'border',
   'input',

package/vite.config.ts

@@ -1,19 +1,11 @@
 import { createAppViteConfig } from '@nocobase/dev-config/vite/app';
 import { loadAppVitePlugins } from '@nocobase/dev-config/vite/plugins';
-import agentAnnotations from '@gchust/agent-annotations/vite';
 import path from 'path';
 import {
   createDevClientConfigPlugin,
   createDevProxy,
 } from '@nocobase/app-cli/dev/proxy';
 
-const AGENT_ANNOTATIONS_DISABLED_VALUES = new Set(['false', '0', 'no', 'off']);
-
-function isAgentAnnotationsEnabled(value: string | undefined): boolean {
-  const normalized = value?.trim().toLowerCase();
-  return !normalized || !AGENT_ANNOTATIONS_DISABLED_VALUES.has(normalized);
-}
-
 const numberFromEnv = (value: string | undefined): number | undefined => {
   const parsed = Number(value);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
@@ -32,9 +24,6 @@ export default createAppViteConfig(async (environment) => {
     command === 'serve'
       ? createDevClientConfigPlugin(appBase, env.PROXY_TARGET_URL)
       : undefined;
-  const annotationsEnabled = isAgentAnnotationsEnabled(
-    env.AGENT_ANNOTATIONS_ENABLED,
-  );
   const viteHmrHost = env.APP_VITE_HMR_HOST;
   const viteDevPort = numberFromEnv(env.APP_VITE_DEV_PORT) ?? 5173;
 
@@ -44,16 +33,6 @@ export default createAppViteConfig(async (environment) => {
     plugins: [
       ...(await loadAppVitePlugins({ appRoot: __dirname, environment })),
       ...(devClientConfig ? [devClientConfig] : []),
-      ...(annotationsEnabled
-        ? [
-            agentAnnotations({
-              root: __dirname,
-              clientExtensions: [
-                path.resolve(__dirname, 'client/agent-annotations-host.ts'),
-              ],
-            }),
-          ]
-        : []),
     ],
     server: {
       proxy:
@@ -62,7 +41,6 @@ export default createAppViteConfig(async (environment) => {
           : undefined,
       watch: {
         ignored: [
-          '**/.agent-annotations/**',
           '**/storage/**',
           // Vite only excludes dist/client automatically. The server build and
           // vendored packages also live in dist and can exhaust file watchers.

package/vitest.config.ts

@@ -15,6 +15,7 @@ export default createReactVitestConfig({
           // together with every client that resolves the authentication tokens and provider.
           /@nocobase\/app-plugin-(?:authentication|api-keys|users)\/(?:dist\/)?client\//u,
           /@nocobase\/app-plugin-authorization\/(?:dist\/)?client\//u,
+          /@nocobase\/app-plugin-(?:lifecycle-example|office-flows-example)\/(?:dist\/)?client\//u,
           /@nocobase\/app-plugin-notification-in-app\/(?:dist\/)?client\//u,
         ],
       },

package/client/agent-annotations-host.ts

@@ -1,25 +0,0 @@
-import { defineClientExtension } from '@gchust/agent-annotations/extension';
-
-export default defineClientExtension({
-  id: 'nocobase.theme',
-  apiVersion: 1,
-  host: {
-    theme: () =>
-      document.documentElement.classList.contains('dark') ? 'dark' : 'light',
-    brandColor: () => {
-      const primary = getComputedStyle(document.documentElement)
-        .getPropertyValue('--primary')
-        .trim();
-      // The annotation host accepts only #RRGGBB; custom themes may use other CSS color formats.
-      return /^#[\da-f]{6}$/i.test(primary) ? primary : '#002ad1';
-    },
-    subscribe(listener) {
-      const observer = new MutationObserver(listener);
-      observer.observe(document.documentElement, {
-        attributeFilter: ['class', 'data-theme'],
-        attributes: true,
-      });
-      return () => observer.disconnect();
-    },
-  },
-});