@nocobase/app-template-default 1.0.0-beta.84 → 1.0.0-beta.86

package/tests/fixtures/permission-alignment.tsx

@@ -0,0 +1,124 @@
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { PermissionEditor } from '../../client/components/permission-editor';
+import { Button } from '../../client/components/ui/button';
+import { AppThemeProvider } from '../../client/theme';
+import '../../client/styles.css';
+
+// A browser fixture for real editor geometry; no server permissions are changed.
+const fields = [
+  'Alerts',
+  'Monitoring rules',
+  'Business processes',
+  'Rule calculations with a deliberately long English label',
+  'Process nodes',
+];
+const levels = [
+  { value: '', label: 'No additional record access' },
+  { value: 'all', label: 'All records' },
+  { value: 'custom', label: 'Custom conditions' },
+];
+
+export default function Fixture() {
+  const params = new URLSearchParams(location.search);
+  const readOnly = params.has('readonly');
+  const chinese = params.has('chinese');
+  const [enabled, setEnabled] = useState<Record<string, boolean>>({});
+  const [values, setValues] = useState<Record<string, string>>({});
+  const [condition, setCondition] = useState(false);
+  return (
+    <AppThemeProvider>
+      <main className='mx-auto grid max-w-6xl gap-4 p-4'>
+        <h1 className='text-xl'>
+          Roles and permissions · Alignment verification
+        </h1>
+        <PermissionEditor
+          readOnly={readOnly}
+          sections={[
+            {
+              id: 'business',
+              title: 'Business operations',
+              groups: [
+                ...['Alerts', 'Monitoring rules', 'Responsible units'].map(
+                  (group) => ({
+                    id: group,
+                    title: group,
+                    rows: (group === 'Monitoring rules'
+                      ? ['View', 'Configure', 'Run']
+                      : ['Manage']
+                    ).map((action) => {
+                      const id = `${action} ${group.toLowerCase()}`;
+                      return {
+                        id,
+                        label: id,
+                        levels: [],
+                        hint: 'Existing permission descriptions remain visible.',
+                        enabled: enabled[id] ?? true,
+                        scopes: (group === 'Responsible units'
+                          ? ['Responsible units']
+                          : group === 'Alerts'
+                            ? fields.slice(0, 2)
+                            : fields
+                        ).map((label, index) => {
+                          const scopeId = `${id}:${index}`;
+                          return {
+                            id: scopeId,
+                            label:
+                              chinese && index === 3
+                                ? '需要完整显示名称的跨部门监控规则计算数据范围长标签'
+                                : label,
+                            levels,
+                            level:
+                              values[scopeId] ?? (index === 0 ? 'custom' : ''),
+                            hint:
+                              index % 2 === 0
+                                ? 'Other roles and default rules still apply.'
+                                : undefined,
+                            configuration:
+                              index === 0 ? (
+                                <Button
+                                  size='sm'
+                                  variant='outline'
+                                  disabled={readOnly}
+                                  onClick={() =>
+                                    setCondition((value) => !value)
+                                  }
+                                >
+                                  Conditions
+                                </Button>
+                              ) : undefined,
+                          };
+                        }),
+                      };
+                    }),
+                  }),
+                ),
+                {
+                  id: 'without-ranges',
+                  title: 'Other operations',
+                  rows: [
+                    { id: 'create', label: 'Create alert', enabled: true },
+                    { id: 'delete', label: 'Delete alert', enabled: false },
+                  ],
+                },
+              ],
+            },
+          ]}
+          onEnabledChange={(id, value) =>
+            setEnabled((current) => ({ ...current, [id]: value }))
+          }
+          onLevelChange={(id, value) =>
+            setValues((current) => ({ ...current, [id]: value }))
+          }
+        />
+        <p role='status'>
+          {condition
+            ? 'Condition editor requested'
+            : 'No condition editor requested'}
+        </p>
+      </main>
+    </AppThemeProvider>
+  );
+}
+
+createRoot(document.getElementById('root')!).render(<Fixture />);

package/tests/playwright/permission-alignment.test.ts

@@ -0,0 +1,109 @@
+import { expect, test } from '@playwright/test';
+
+const applicationUrl = process.env.APP_URL;
+test.skip(!applicationUrl, 'Set APP_URL to the running application entry.');
+const fixture = `${applicationUrl?.replace(/\/$/, '')}/tests/fixtures/permission-alignment.html`;
+
+for (const width of [1440, 1024, 768, 390, 375, 360]) {
+  test(`aligns scopes across groups and actions at ${width}px`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width, height: 1100 });
+    await page.goto(fixture);
+    await expect(page.getByRole('combobox')).toHaveCount(18);
+    const geometry = await Promise.all(
+      (await page.getByRole('combobox').all()).map(async (node) => {
+        const rect = (await node.boundingBox())!;
+        return { x: Math.round(rect.x), width: Math.round(rect.width) };
+      }),
+    );
+    expect(new Set(geometry.map((item) => item.x)).size).toBe(
+      width >= 1024 ? 2 : 1,
+    );
+    expect(new Set(geometry.map((item) => item.width)).size).toBe(1);
+    expect(
+      await page.locator('html').evaluate((element) => {
+        const root = element as unknown as {
+          scrollWidth: number;
+          clientWidth: number;
+        };
+        return root.scrollWidth <= root.clientWidth;
+      }),
+    ).toBe(true);
+    for (const row of await page.locator('[data-slot=permission-row]').all()) {
+      const checkbox = await row.getByRole('checkbox').boundingBox();
+      const controls = row.getByRole('combobox');
+      if (await controls.count()) {
+        const first = await controls.first().boundingBox();
+        expect(first!.y).toBeGreaterThan(checkbox!.y + checkbox!.height);
+        expect(Math.round(first!.x)).toBe(
+          Math.min(...geometry.map((item) => item.x)),
+        );
+        if ((await controls.count()) % 2 === 1) {
+          const last = await controls.last().boundingBox();
+          expect(Math.round(last!.x)).toBe(Math.round(first!.x));
+        }
+      }
+    }
+    for (const scope of await page
+      .locator('[data-slot=permission-scope]')
+      .all()) {
+      const trigger = await scope.getByRole('combobox').boundingBox();
+      if (width < 416) {
+        const label = await scope.locator('span[title]').boundingBox();
+        expect(label!.y + label!.height).toBeLessThanOrEqual(trigger!.y);
+        expect(Math.round(label!.x)).toBe(Math.round(trigger!.x));
+      }
+      const conditions = scope.getByRole('button', {
+        name: 'Conditions',
+        exact: true,
+      });
+      if (await conditions.count()) {
+        const button = await conditions.boundingBox();
+        expect(button!.y).toBeGreaterThanOrEqual(trigger!.y + trigger!.height);
+        expect(Math.round(button!.x)).toBe(Math.round(trigger!.x));
+      }
+    }
+  });
+}
+
+test('preserves long labels, independent scope changes and ungranted visibility', async ({
+  page,
+}) => {
+  await page.goto(`${fixture}?chinese`);
+  const label = '需要完整显示名称的跨部门监控规则计算数据范围长标签';
+  await expect(page.getByTitle(label)).toHaveCount(3);
+  const control = page.getByRole('combobox', {
+    name: `How far View monitoring rules · ${label} reaches`,
+  });
+  await control.click();
+  await page.getByRole('option', { name: 'All records', exact: true }).click();
+  await expect(control.locator('[data-slot=select-value]')).toHaveText(
+    'All records',
+  );
+  await expect(
+    page.getByRole('checkbox', { name: 'View monitoring rules', exact: true }),
+  ).toBeChecked();
+  await page
+    .getByRole('checkbox', { name: 'Manage responsible units', exact: true })
+    .click();
+  await expect(page.getByRole('combobox')).toHaveCount(17);
+  await page.getByRole('tab', { name: 'Ungranted', exact: true }).click();
+  await expect(page.getByRole('combobox')).toHaveCount(0);
+});
+
+test('keeps readonly scopes visible and disables editing', async ({ page }) => {
+  await page.goto(`${fixture}?readonly`);
+  await expect(page.getByRole('combobox')).toHaveCount(18);
+  for (const control of await page.getByRole('combobox').all()) {
+    await expect(control).toBeDisabled();
+  }
+  for (const button of await page
+    .getByRole('button', { name: 'Conditions', exact: true })
+    .all()) {
+    await expect(button).toBeDisabled();
+  }
+  await expect(
+    page.getByRole('checkbox', { name: 'Manage alerts', exact: true }),
+  ).toHaveAttribute('aria-disabled', 'true');
+});

package/tests/server/auth-email-config.test.ts

@@ -0,0 +1,79 @@
+// @vitest-environment node
+
+import { readFile, mkdtemp, writeFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { expect, it } from 'vitest';
+import {
+  AppConfig,
+  defaultAppConfigs,
+  buildVariablesManifest,
+} from '@nocobase/app-server/config';
+import auth from '../../server/config/auth.js';
+
+it('inherits private authentication sender mappings without changing other mail consumers', async () => {
+  const defaults = defaultAppConfigs({ auth });
+  const config = new AppConfig();
+  await config.loadAll();
+  config.mergeDefaults(defaults({} as never));
+  config.defineSections(defaults.sections!);
+  await config.loadSectionEnvironment({
+    AUTH_EMAIL_PROVIDER: 'smtp',
+    AUTH_EMAIL_HOST: 'smtp.example.test',
+    AUTH_EMAIL_PORT: '587',
+    AUTH_EMAIL_SECURE: 'false',
+    AUTH_EMAIL_FROM: 'sender@example.test',
+    AUTH_EMAIL_PASSWORD: 'synthetic-password',
+    AUTH_EMAIL_USER: 'synthetic',
+    MAIL_HOST: 'unrelated.example.test',
+  });
+  expect(await config.validate()).toEqual([]);
+  expect(config.get('auth.email.host')).toBe('smtp.example.test');
+  expect(config.get('auth.email.port')).toBe(587);
+  expect(config.get('auth.email.secure')).toBe(false);
+  expect(JSON.stringify(config.publicValues())).not.toContain(
+    'synthetic-password',
+  );
+  expect(config.get('auth.passwordReset.enabled')).toBeUndefined();
+  const variables = buildVariablesManifest({
+    app: { name: 'synthetic' },
+    variables: config.environmentVariableMappings(),
+    defaults: config.layers().defaults,
+  }).variables;
+  expect(
+    variables.filter((variable) => variable.name.startsWith('AUTH_EMAIL_')),
+  ).toHaveLength(9);
+  expect(
+    variables
+      .filter((variable) => variable.name.startsWith('AUTH_EMAIL_'))
+      .every((variable) => variable.required === false),
+  ).toBe(true);
+});
+
+it('ships separate, valid SMTP and Resend authentication examples', async () => {
+  const example = await readFile(
+    new URL('../../config.example.yml', import.meta.url),
+    'utf8',
+  );
+  const blocks = [...example.matchAll(/^ {2}# email:\n(?: {2}# {3}.*\n)+/gm)];
+  expect(blocks).toHaveLength(2);
+  const directory = await mkdtemp(
+    path.join(os.tmpdir(), 'auth-email-example-'),
+  );
+  try {
+    for (const block of blocks) {
+      const text = 'auth:\n' + block[0].replace(/^ {2}# /gm, '  ');
+      const file = path.join(directory, 'config.yml');
+      await writeFile(file, text);
+      const config = new AppConfig().loadFile(file);
+      await config.loadAll();
+      const defaults = defaultAppConfigs({ auth });
+      config.mergeDefaults(defaults({} as never));
+      config.defineSections(defaults.sections!);
+      expect(await config.validate()).toEqual([]);
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+  expect(example).not.toContain('emailChannel:');
+});

package/tests/server/concurrency.test.ts

@@ -0,0 +1,125 @@
+import { expect, it, vi } from 'vitest';
+import { ConcurrentAbortError } from '@nocobase/concurrency';
+import { createAppTest } from '@nocobase/app-testing/server';
+import {
+  concurrencyServiceToken,
+  type ConcurrencyService,
+} from '@nocobase/app-plugin-concurrency/server';
+import { createStandaloneServer } from '../../server/standalone.js';
+import concurrency from '../../server/config/concurrency.js';
+
+class BusinessConsumer {
+  public constructor(private readonly service: ConcurrencyService) {}
+  public manager() {
+    return this.service.getManager('memory');
+  }
+}
+
+const test = createAppTest({
+  createServer: createStandaloneServer,
+  connections: ['main'],
+  config: {
+    app: { publicOrigin: 'http://localhost' },
+    auth: { secret: 'test-auth-secret-at-least-32-characters' },
+  },
+});
+
+test('explicit ttl keeps local Lock and Executor mutually exclusive until actual release', async ({
+  app,
+}) => {
+  const manager = await app.container
+    .resolve(concurrencyServiceToken)
+    .getManager();
+  const lock = await manager.createLock('concurrency-test:ttl', { ttl: 1 });
+  const executor = await manager.createSynchronous('concurrency-test:ttl', {
+    ttl: 2,
+  });
+  vi.useFakeTimers();
+  try {
+    const held = await lock.lock();
+    let entered = false;
+    const done = Promise.withResolvers<string>();
+    const running = executor.run(() => {
+      entered = true;
+      return done.promise;
+    });
+    try {
+      await vi.advanceTimersByTimeAsync(1000);
+      expect(entered).toBe(false);
+      await held.release();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(entered).toBe(true);
+      let successorEntered = false;
+      const next = lock.lock().then((lease) => {
+        successorEntered = true;
+        return lease;
+      });
+      await vi.advanceTimersByTimeAsync(1000);
+      expect(successorEntered).toBe(false);
+      done.resolve('actual');
+      expect(await running).toBe('actual');
+      const successor = await next;
+      await held.release();
+      const attempt = executor.tryRun(() => 'wrong', 10);
+      await vi.advanceTimersByTimeAsync(10);
+      expect(await attempt).toEqual({ acquired: false });
+      await successor.release();
+    } finally {
+      done.resolve('actual');
+      await running;
+      await held.release();
+    }
+  } finally {
+    vi.useRealTimers();
+  }
+});
+test('the real default composition supplies one memory lock domain to two business consumers', async ({
+  app,
+}) => {
+  const service = app.container.resolve(concurrencyServiceToken);
+  const first = new BusinessConsumer(service);
+  const second = new BusinessConsumer(service);
+  expect(app.config.get('concurrency')).toEqual({
+    default: 'memory',
+    memory: { adapter: 'mutex' },
+  });
+  const [left, right] = await Promise.all([first.manager(), second.manager()]);
+  expect(left).toBe(right);
+  expect(left).toBe(await service.getManager());
+  const lock = await left.createLock('concurrency-test:business');
+  const executor = await right.createSynchronous('concurrency-test:business');
+  const lease = await lock.lock();
+  try {
+    expect(await executor.tryRun(() => 'should-not-run')).toEqual({
+      acquired: false,
+    });
+  } finally {
+    await lease.release();
+  }
+  expect(await executor.tryRun(() => 'done')).toEqual({
+    acquired: true,
+    value: 'done',
+  });
+  const cancellation = new AbortController();
+  const held = await lock.lock();
+  const cancelled = lock
+    .lock({ signal: cancellation.signal })
+    .catch((error: unknown) => error);
+  cancellation.abort();
+  expect(await cancelled).toBeInstanceOf(ConcurrentAbortError);
+  await held.release();
+  const active = await lock.lock();
+  const interrupted = lock.lock().catch((error: unknown) => error);
+  await app.shutdown();
+  expect(await interrupted).toBeInstanceOf(ConcurrentAbortError);
+  await active.release();
+  await expect(lock.lock()).rejects.toBeInstanceOf(ConcurrentAbortError);
+});
+
+it('declares only the default selector environment variable and no public configuration', () => {
+  expect(concurrency.rules?.public).toEqual([]);
+  expect(Object.keys(concurrency.rules?.env ?? {})).toEqual([
+    'CONCURRENCY_DEFAULT',
+  ]);
+  expect(concurrency.rules?.validators).toHaveLength(1);
+});

package/tests/server/config.test.ts

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'node:url';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -33,6 +33,37 @@ describe('application config', () => {
     await rm(configRoot, { recursive: true, force: true });
   });
 
+  it('merges the Redis YAML example with the real template defaults', async () => {
+    const source = await readFile(
+      new URL('../../config.example.yml', import.meta.url),
+      'utf8',
+    );
+    const example = source.match(/^# jobs:\n(?:#(?: {2,}.*)?\n)*/m)?.[0];
+    expect(example).toBeDefined();
+    const examplePath = path.join(configRoot, 'redis-example.yml');
+    await writeFile(
+      examplePath,
+      source.replace(example!, example!.replace(/^# ?/gm, '')),
+    );
+    const runtime = await resolveStandaloneAppRuntime(appRuntime, {
+      rootDir: templateRootDir,
+      configPath: examplePath,
+      env: { AUTH_SECRET: 'test-auth-secret-at-least-32-characters' },
+    });
+
+    expect(runtime.config.get<AppJobsConfig>('jobs')).toEqual({
+      memory: {
+        adapter: 'memory',
+        persistence: { path: runtime.paths.storage('jobs') },
+      },
+      default: 'redis',
+      redis: {
+        adapter: 'redis',
+        connection: { host: '127.0.0.1', port: 6379 },
+      },
+    });
+  });
+
   it('assembles module defaults in the runtime', async () => {
     const runtime = await resolveStandaloneAppRuntime(appRuntime, {
       rootDir: templateRootDir,
@@ -76,24 +107,12 @@ describe('application config', () => {
         adapter: 'inMemory',
         persistence: { path: runtime.paths.storage('queue') },
       },
-      redis: {
-        adapter: 'redis',
-        connection: { host: '127.0.0.1', port: 6379, db: 0 },
-        removeOnComplete: { count: 1000 },
-        removeOnFail: { age: 604_800 },
-      },
     });
     expect(runtime.config.get<AppJobsConfig>('jobs')).toEqual({
       memory: {
         adapter: 'memory',
         persistence: { path: runtime.paths.storage('jobs') },
       },
-      redis: {
-        adapter: 'redis',
-        connection: { host: '127.0.0.1', port: 6379, db: 0 },
-        removeOnComplete: { count: 1000 },
-        removeOnFail: { age: 604_800 },
-      },
     });
     expect(runtime.config.get<AppSessionConfigInput>('session')!.default).toBe(
       'memory',
@@ -183,7 +202,8 @@ describe('application config', () => {
     });
     expect(runtime.config.get('server.port')).toBe(14001);
     expect(runtime.config.get('server.startLog')).toBe(false);
-    expect(runtime.config.get('queue.redis.connection.host')).toBe('127.0.0.1');
+    expect(runtime.config.get('queue.redis')).toBeUndefined();
+    expect(runtime.config.get('queue.memory.adapter')).toBe('inMemory');
     expect(runtime.config.get('session.stores.redis.host')).toBe('127.0.0.1');
     expect(runtime.config.get('logging.console.pretty')).toBe(false);
     expect(runtime.config.get('session.cookie.secure')).toBe(true);

package/client/route-overrides.ts

@@ -1,9 +0,0 @@
-import {
-  defineClientRouteComponentOverrides,
-  type AppClientRouteComponentOverrideDefinition,
-} from '@nocobase/app-client/plugins';
-
-export const routeComponentOverrides: readonly AppClientRouteComponentOverrideDefinition[] =
-  defineClientRouteComponentOverrides([]);
-
-export default routeComponentOverrides;

package/client/source-extensions.ts

@@ -1,19 +0,0 @@
-import type { AppClientSourceExtension } from '@nocobase/app-client/plugins';
-
-interface AppClientSourceExtensionModule {
-  readonly default: AppClientSourceExtension;
-}
-
-const extensionModules = import.meta.glob<AppClientSourceExtensionModule>(
-  './extensions/*/extension.ts',
-  { eager: true },
-);
-
-export const sourceExtensions: readonly AppClientSourceExtension[] =
-  Object.freeze(
-    Object.entries(extensionModules)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([, module]) => module.default),
-  );
-
-export default sourceExtensions;