@nocobase/app-template-default 0.0.0-stage → 1.0.0-beta.57

package/server/locales/index.ts

@@ -0,0 +1,10 @@
+import type { LocaleLoaders } from '@nocobase/i18n';
+
+// The languages the application offers. A plugin's locale file supplies translations for the languages listed here;
+// it never adds one, so a language belongs in this map before anything can be served in it.
+const locales: LocaleLoaders = {
+  'en-US': () => import('./en-US.js'),
+  'zh-CN': () => import('./zh-CN.js'),
+};
+
+export default locales;

package/server/locales/zh-CN.ts

@@ -0,0 +1,5 @@
+import type { AppServerResource } from './en-US.js';
+
+const zhCN: AppServerResource = {};
+
+export default zhCN;

package/server/plugins.ts

@@ -0,0 +1,41 @@
+import defaultAccess from '@nocobase/app-plugin-authz-default-access/server';
+import sharingRules from '@nocobase/app-plugin-authz-sharing-rules/server';
+import restrictionRules from '@nocobase/app-plugin-authz-restriction-rules/server';
+import apiKeys from '@nocobase/app-plugin-api-keys/server';
+import authentication from '@nocobase/app-plugin-authentication/server';
+import aiEmployee from '@nocobase/app-plugin-ai-employee/server/plugin';
+import authorization from '@nocobase/app-plugin-authorization/server';
+import databaseExplorer from '@nocobase/app-plugin-database-explorer/server';
+import users from '@nocobase/app-plugin-users/server';
+import i18n from '@nocobase/app-plugin-i18n/server';
+import notification from '@nocobase/app-plugin-notification/server';
+import notificationInApp from '@nocobase/app-plugin-notification-in-app/server';
+import notificationProviders from '@nocobase/app-plugin-notification-providers/server';
+import workflow from '@nocobase/app-plugin-workflow/server';
+import {
+  defineServerPlugins,
+  type AppServerPlugins,
+} from '@nocobase/app-server/plugins';
+import scheduler from '@nocobase/app-plugin-scheduler/server';
+import file from '@nocobase/app-plugin-file/server';
+
+const serverPlugins: AppServerPlugins = defineServerPlugins([
+  authentication,
+  aiEmployee,
+  authorization,
+  defaultAccess,
+  sharingRules,
+  restrictionRules,
+  databaseExplorer,
+  users,
+  apiKeys,
+  i18n,
+  notification,
+  notificationInApp,
+  notificationProviders,
+  workflow,
+  file,
+  scheduler,
+]);
+
+export default serverPlugins;

package/server/providers/index.ts

@@ -0,0 +1,5 @@
+import type { ApplicationServiceProviderConstructor } from '@nocobase/app-server/application';
+
+const serviceProviders: readonly ApplicationServiceProviderConstructor[] = [];
+
+export default serviceProviders;

package/server/routes/index.ts

@@ -0,0 +1,6 @@
+import type { Application } from '@nocobase/app-server/application';
+import type { AppRouteContribution } from '@nocobase/app-server/router';
+
+const routes: readonly AppRouteContribution<Application>[] = [];
+
+export default routes;

package/server/runtime.ts

@@ -0,0 +1,24 @@
+import defaultConfigs from './config/index.js';
+import {
+  defineAppRuntime,
+  type AppRuntimeDefinition,
+} from '@nocobase/app-server/runtime';
+
+import { createAppConfig } from './config.js';
+import plugins from './plugins.js';
+import serviceProviders from './providers/index.js';
+import routes from './routes/index.js';
+import locales from './locales/index.js';
+
+const appRuntime: AppRuntimeDefinition = defineAppRuntime({
+  deploymentRootDir: import.meta.filename.endsWith('.ts') ? '.' : '..',
+  createAppConfig,
+  defaultConfigs,
+  plugins,
+  serviceProviders,
+  routes,
+  // The application's own server locale files, which are what decides the languages the server offers.
+  locales,
+});
+
+export default appRuntime;

package/server/standalone.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+
+import {
+  defineStandaloneServer,
+  type StandaloneServer as CoreStandaloneServer,
+  type StandaloneServerOptions as CoreStandaloneServerOptions,
+} from '@nocobase/app-server/node';
+
+import { createServer } from './embedded.js';
+import appRuntime from './runtime.js';
+
+const standalone = defineStandaloneServer({
+  rootDir: path.resolve(import.meta.dirname, '..'),
+  appRuntime,
+  createServer,
+});
+
+export type StandaloneServer = CoreStandaloneServer;
+
+export type StandaloneServerOptions = CoreStandaloneServerOptions;
+
+export const createStandaloneServer: (
+  options?: StandaloneServerOptions,
+) => Promise<StandaloneServer> = standalone.create;
+
+export const startServer: (options?: StandaloneServerOptions) => void =
+  standalone.start;
+
+if (import.meta.main) startServer();

package/server/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig.server.json",
+  "include": ["**/*.ts"]
+}

package/tailwind.config.mjs

@@ -0,0 +1,59 @@
+// Tells Tailwind which plugin files to scan for utility classes.
+//
+// `@source "../node_modules/@nocobase/app-plugin-*/client"` cannot do this job. pnpm links every dependency as a
+// symlink into its store, and Tailwind's scanner does not expand a wildcard through one — the glob silently matches
+// nothing, in this repository and in a generated application alike. Reading the directory first and resolving each
+// match to its real path gets past that, because `readdirSync` sees the symlinks and `realpathSync` resolves them.
+//
+// Client runtime files and canonical Registry source are both searched. A workspace plugin exposes TypeScript sources,
+// while an installed one may expose build output plus application-owned Registry recipes. Missing directories are skipped.
+import { existsSync, globSync, readdirSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+
+const SOURCE_DIRECTORIES = [
+  'client',
+  'dist/client',
+  'src',
+  'dist/src',
+  'registry',
+];
+const SCANNED_FILES = '**/*.{js,jsx,ts,tsx}';
+
+/** Every scannable directory a workspace or installed `@nocobase` package exposes. */
+function scannedDirectories(appRoot) {
+  const scope = path.resolve(appRoot, 'node_modules/@nocobase');
+  if (!existsSync(scope)) {
+    return [];
+  }
+
+  const directories = [];
+  for (const packageName of readdirSync(scope)) {
+    // app-client contributes the shared components an application renders; the plugins contribute their own pages.
+    if (
+      !packageName.startsWith('app-plugin-') &&
+      packageName !== 'app-client'
+    ) {
+      continue;
+    }
+    for (const directory of SOURCE_DIRECTORIES) {
+      const candidate = path.join(scope, packageName, directory);
+      if (existsSync(candidate)) {
+        directories.push(realpathSync(candidate));
+      }
+    }
+  }
+  return directories;
+}
+
+/** Exported so a test can drive the resolution over a fixture laid out the way pnpm lays out an installed package. */
+export function contentFilesIn(appRoot) {
+  const files = [];
+  for (const directory of scannedDirectories(appRoot)) {
+    for (const file of globSync(SCANNED_FILES, { cwd: directory })) {
+      files.push(path.join(directory, file));
+    }
+  }
+  return files;
+}
+
+export default { content: contentFilesIn(import.meta.dirname) };

package/tests/components/app-layout-routes.test.tsx

@@ -0,0 +1,132 @@
+import { usePageBreadcrumb } from '@nocobase/app-client';
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import {
+  TestI18nProvider,
+  createTestI18nRuntime,
+} from '@nocobase/i18n/testing';
+import { render, screen, within } from '@testing-library/react';
+import type { ReactElement, ReactNode } from 'react';
+import { MemoryRouter, Route, Routes } from 'react-router';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+
+import { AppLayout } from '../../client/layouts/app-layout.js';
+import enUS from '../../client/locales/en-US.js';
+
+// Breadcrumb titles are route data, not keys any namespace owns: the trail translates each through its package's
+// namespace with the title itself as `defaultValue`, so the runtime is not strict.
+const runtime = await createTestI18nRuntime({
+  application: { namespace: '@nocobase/app-template-default', resources: enUS },
+  strict: false,
+});
+
+function I18n({ children }: { readonly children: ReactNode }) {
+  return <TestI18nProvider runtime={runtime}>{children}</TestI18nProvider>;
+}
+
+vi.mock('@nocobase/app-plugin-i18n/client', async (importOriginal) => ({
+  ...(await importOriginal<
+    typeof import('@nocobase/app-plugin-i18n/client')
+  >()),
+  useSyncServerLocale: () => {},
+}));
+vi.mock('@nocobase/app-client', async (original) => ({
+  ...(await original<typeof import('@nocobase/app-client')>()),
+  useClientApplication: () => ({ runtime: { settingsRouteTree: [] } }),
+}));
+vi.mock('../../client/routing/route-navigation.js', async (original) => ({
+  ...(await original<
+    typeof import('../../client/routing/route-navigation.js')
+  >()),
+  useRouteNavigation: () => ({ items: [], denied: new Set(), loading: false }),
+}));
+vi.mock('../../client/layouts/components/app-sidebar.js', async (original) => ({
+  ...(await original<
+    typeof import('../../client/layouts/components/app-sidebar.js')
+  >()),
+  AppSidebar: () => null,
+}));
+beforeEach(() =>
+  vi.stubGlobal('matchMedia', () => ({
+    matches: false,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  })),
+);
+afterEach(() => vi.unstubAllGlobals());
+vi.mock('../../client/layouts/components/header-actions.js', () => ({
+  HeaderActions: () => null,
+}));
+
+const detail: AppClientRegisteredRoute = {
+  id: 'detail',
+  name: 'detail',
+  packageName: 'test',
+  source: 'application',
+  auth: 'required',
+  path: '/orders/:id',
+  breadcrumb: { title: 'Detail' },
+  componentLoader: async () => ({ default: () => null }),
+};
+const routes = [
+  {
+    ...detail,
+    id: 'orders',
+    name: 'orders',
+    path: '/orders',
+    breadcrumb: { title: 'Orders' },
+    children: [detail],
+  },
+];
+
+function OrderPage(): ReactElement {
+  usePageBreadcrumb([
+    { label: 'Orders', to: '/orders?status=open' },
+    { label: 'Order #42' },
+  ]);
+  return <h1>Order #42</h1>;
+}
+
+function renderLayout(page: ReactElement): HTMLElement {
+  render(
+    <MemoryRouter initialEntries={['/orders/42']}>
+      <Routes>
+        <Route element={<AppLayout routes={routes} />}>
+          <Route path='/orders/:id' element={page} />
+        </Route>
+      </Routes>
+    </MemoryRouter>,
+    { wrapper: I18n },
+  );
+  return screen.getByRole('banner');
+}
+
+it('shows the route trail of a nested page in its header', () => {
+  const header = renderLayout(<h1>Detail page</h1>);
+  const trail = within(header).getByRole('navigation', { name: 'Breadcrumb' });
+  expect(within(trail).getByRole('link', { name: 'Orders' })).toHaveAttribute(
+    'href',
+    '/orders',
+  );
+  expect(within(trail).getByText('Detail')).toHaveAttribute(
+    'aria-current',
+    'page',
+  );
+  // The header carries the only trail: the page renders none of its own.
+  expect(
+    screen.getAllByRole('navigation', { name: 'Breadcrumb' }),
+  ).toHaveLength(1);
+});
+
+it('shows the trail a page declares, with its record names, in place of the route trail', () => {
+  const header = renderLayout(<OrderPage />);
+  const trail = within(header).getByRole('navigation', { name: 'Breadcrumb' });
+  expect(within(trail).getByRole('link', { name: 'Orders' })).toHaveAttribute(
+    'href',
+    '/orders?status=open',
+  );
+  expect(within(trail).getByText('Order #42')).toHaveAttribute(
+    'aria-current',
+    'page',
+  );
+  expect(within(trail).queryByText('Detail')).toBeNull();
+});

package/tests/components/app-title.test.tsx

@@ -0,0 +1,57 @@
+import { createApp } from '../../client/app.js';
+import { createAppClientConfig } from '@nocobase/app-client';
+import { defineClientPlugins } from '@nocobase/app-client/plugins';
+import {
+  defineAppRuntime,
+  resolveAppRuntime,
+} from '@nocobase/app-client/runtime';
+import { describe, expect, it } from 'vitest';
+
+import { DefaultClientServiceProvider } from '../../client/service-provider.ts';
+
+describe('application title', () => {
+  it('uses the configured title during the application lifecycle', async () => {
+    const previousTitle = 'Host title';
+    document.title = previousTitle;
+    const app = await createTestApp('Configured application');
+
+    await app.start();
+
+    expect(app.refineConfig.options?.title).toEqual({
+      text: 'Configured application',
+    });
+    expect(document.title).toBe('Configured application');
+
+    await app.shutdown();
+    expect(document.title).toBe(previousTitle);
+  });
+
+  it('falls back to NocoBase for a blank configured title', async () => {
+    const previousTitle = 'Host title';
+    document.title = previousTitle;
+    const app = await createTestApp('   ');
+
+    await app.start();
+
+    expect(app.refineConfig.options?.title).toEqual({ text: 'NocoBase' });
+    expect(document.title).toBe('NocoBase');
+
+    await app.shutdown();
+    expect(document.title).toBe(previousTitle);
+  });
+});
+
+async function createTestApp(title: string) {
+  const runtime = await resolveAppRuntime(
+    defineAppRuntime({
+      packageName: '@example/app',
+      createAppConfig: createAppClientConfig,
+      serviceProviders: [DefaultClientServiceProvider],
+      reactProviders: [],
+      routes: [],
+      plugins: defineClientPlugins([]),
+    }),
+    { rawConfig: { app: { title } } },
+  );
+  return createApp(runtime);
+}

package/tests/components/auth-i18n.test.tsx

@@ -0,0 +1,87 @@
+import { I18nRuntime } from '@nocobase/i18n';
+import { I18nProvider } from '@nocobase/i18n/client';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import type { ReactElement } from 'react';
+import { MemoryRouter } from 'react-router';
+import { describe, expect, it, vi } from 'vitest';
+import locales from '../../client/locales/index.js';
+import ForgotPasswordPage from '../../client/pages/auth/forgot-password.js';
+import LoginPage from '../../client/pages/auth/login.js';
+import RegisterPage from '../../client/pages/auth/register.js';
+import ResetPasswordPage from '../../client/pages/auth/reset-password.js';
+import { Loading } from '../../client/components/loading.js';
+
+vi.mock('@nocobase/app-plugin-authentication/client', () => ({
+  useSignUpAvailable: () => true,
+}));
+
+vi.mock('@nocobase/app-plugin-authentication/client/actions', () => ({
+  usePasswordLogin: () => ({ isPending: false, submit: vi.fn() }),
+  usePasswordRegistration: () => ({ isPending: false, submit: vi.fn() }),
+  usePasswordReset: () => ({ isPending: false, submit: vi.fn() }),
+  usePasswordResetRequest: () => ({
+    isPending: false,
+    isSuccess: true,
+    submit: vi.fn(),
+  }),
+}));
+async function runtime() {
+  const value = new I18nRuntime({
+    applicationNamespace: 'app',
+    defaultLocale: 'en-US',
+    locales: ['en-US', 'zh-CN'],
+  });
+  value.registerApplicationNamespace('app', locales);
+  await value.init('en-US');
+  return value;
+}
+function renderPage(value: I18nRuntime, page: ReactElement) {
+  return render(
+    <I18nProvider runtime={value}>
+      <MemoryRouter>{page}</MemoryRouter>
+    </I18nProvider>,
+  );
+}
+describe('authentication translations', () => {
+  it('updates the login page, brand panel and visibility control on language change', async () => {
+    const value = await runtime();
+    renderPage(value, <LoginPage />);
+    await act(() => value.changeLanguage('zh-CN'));
+    expect(screen.getByRole('heading', { name: '欢迎回来' })).toBeVisible();
+    expect(screen.getByLabelText('用户名或邮箱')).toBeVisible();
+    expect(screen.getByRole('button', { name: '显示密码' })).toBeVisible();
+    expect(screen.getByRole('link', { name: '注册' })).toBeVisible();
+    expect(screen.getByText('AI 原生应用平台')).toBeVisible();
+    await act(() => value.changeLanguage('en-US'));
+    expect(screen.getByRole('heading', { name: 'Welcome back' })).toBeVisible();
+  });
+  it('retranslates an existing password mismatch', async () => {
+    const value = await runtime();
+    const { container } = renderPage(value, <RegisterPage />);
+    fireEvent.change(screen.getByLabelText('Password'), {
+      target: { value: 'one' },
+    });
+    fireEvent.change(screen.getByLabelText('Confirm password'), {
+      target: { value: 'two' },
+    });
+    fireEvent.submit(container.querySelector('form')!);
+    expect(screen.getByText("Passwords don't match.")).toBeVisible();
+    await act(() => value.changeLanguage('zh-CN'));
+    expect(screen.getByText('两次输入的密码不一致。')).toBeVisible();
+  });
+  it('translates reset states and generic loading', async () => {
+    const value = await runtime();
+    renderPage(
+      value,
+      <>
+        <ResetPasswordPage />
+        <ForgotPasswordPage />
+        <Loading />
+      </>,
+    );
+    await act(() => value.changeLanguage('zh-CN'));
+    expect(screen.getByText('此密码重置链接无效或已过期。')).toBeVisible();
+    expect(screen.getByText('如果账户存在，重置链接已发送。')).toBeVisible();
+    expect(screen.getByRole('status', { name: '加载中' })).toBeVisible();
+  });
+});

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

@@ -0,0 +1,80 @@
+import {
+  TestI18nProvider,
+  createTestI18nRuntime,
+} from '@nocobase/i18n/testing';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { ReactElement, ReactNode } from 'react';
+import { createMemoryRouter, Outlet, RouterProvider } from 'react-router';
+import { describe, expect, it } from 'vitest';
+
+import { BackButton } from '#components/back-button';
+
+import enUS from '../../client/locales/en-US.js';
+
+const runtime = await createTestI18nRuntime({
+  application: { namespace: '@nocobase/app-template-default', resources: enUS },
+});
+
+function I18n({ children }: { readonly children: ReactNode }): ReactElement {
+  return <TestI18nProvider runtime={runtime}>{children}</TestI18nProvider>;
+}
+
+function renderAt(url: string, child: ReactElement) {
+  const router = createMemoryRouter(
+    [
+      {
+        path: '/projects',
+        element: (
+          <>
+            <h1>List</h1>
+            <Outlet />
+          </>
+        ),
+        // A child page with a two-segment path, like a second route to the same overlay: `..` is still the list.
+        children: [
+          { path: ':projectId', element: child },
+          { path: 'import/:batchId', element: child },
+        ],
+      },
+      { path: '/overview', element: <h1>Overview</h1> },
+    ],
+    { initialEntries: [url] },
+  );
+  render(<RouterProvider router={router} />, { wrapper: I18n });
+  return router;
+}
+
+describe('BackButton', () => {
+  it('leads to the parent route and keeps the query string', async () => {
+    const router = renderAt('/projects/12?q=alpha&page=2', <BackButton />);
+
+    const link = screen.getByRole('link', { name: enUS.navigation.back });
+    expect(link).toHaveAttribute('href', '/projects?q=alpha&page=2');
+
+    await userEvent.click(link);
+    expect(router.state.location.pathname).toBe('/projects');
+    expect(router.state.location.search).toBe('?q=alpha&page=2');
+    // Leaving the child page replaces its entry, as closing an overlay does.
+    expect(router.state.historyAction).toBe('REPLACE');
+  });
+
+  it('resolves the parent by route, not by path segment', () => {
+    renderAt('/projects/import/7', <BackButton />);
+
+    expect(
+      screen.getByRole('link', { name: enUS.navigation.back }),
+    ).toHaveAttribute('href', '/projects');
+  });
+
+  it('takes a destination and a label of its own', () => {
+    renderAt(
+      '/projects/12',
+      <BackButton to='/overview'>Back to the overview</BackButton>,
+    );
+
+    expect(
+      screen.getByRole('link', { name: 'Back to the overview' }),
+    ).toHaveAttribute('href', '/overview');
+  });
+});

package/tests/components/file-preview.test.tsx

@@ -0,0 +1,101 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+
+import {
+  FilePreviewDialog,
+  type FileRecord,
+} from '../../client/extensions/nocobase-file-component-ui/index';
+
+const viewer = vi.hoisted(() => ({
+  load: vi.fn<(data: ArrayBuffer) => Promise<void>>(),
+  destroy: vi.fn(),
+}));
+
+vi.mock('@silurus/ooxml/docx', () => ({
+  DocxScrollViewer: class {
+    load = viewer.load;
+    destroy = viewer.destroy;
+  },
+}));
+vi.mock('@silurus/ooxml/xlsx', () => ({
+  XlsxViewer: class {
+    load = viewer.load;
+    destroy = viewer.destroy;
+  },
+}));
+vi.mock('@silurus/ooxml/pptx', () => ({
+  PptxScrollViewer: class {
+    load = viewer.load;
+    destroy = viewer.destroy;
+  },
+}));
+
+function file(ext: string): FileRecord {
+  return {
+    id: 'attachment',
+    filename: `attachment.${ext}`,
+    ext,
+    mimeType: 'application/octet-stream',
+    size: 3,
+    createdAt: '2026-09-20T00:00:00.000Z',
+    updatedAt: '2026-09-20T00:00:00.000Z',
+    contentUrl: `/main/expense-files/attachment.${ext}`,
+  };
+}
+
+beforeEach(() => {
+  viewer.load.mockReset().mockResolvedValue(undefined);
+  viewer.destroy.mockReset();
+});
+afterEach(() => vi.unstubAllGlobals());
+
+it.each(['docx', 'xlsx', 'pptx'])(
+  'preinstalled preview fetches private %s content for the local viewer',
+  async (ext) => {
+    const fetchMock = vi
+      .fn<typeof fetch>()
+      .mockResolvedValue(new Response(new Uint8Array([1, 2, 3])));
+    vi.stubGlobal('fetch', fetchMock);
+    const { unmount } = render(
+      <FilePreviewDialog files={[file(ext)]} open onOpenChange={vi.fn()} />,
+    );
+    await waitFor(() => expect(viewer.load).toHaveBeenCalledOnce());
+    expect(fetchMock).toHaveBeenCalledWith(
+      `/main/expense-files/attachment.${ext}`,
+      {
+        credentials: 'same-origin',
+        signal: expect.any(AbortSignal),
+      },
+    );
+    expect(new Uint8Array(viewer.load.mock.calls[0]![0])).toEqual(
+      new Uint8Array([1, 2, 3]),
+    );
+    expect(
+      document.querySelector(`[data-office-open-xml-format="${ext}"]`),
+    ).not.toBeNull();
+    expect(document.querySelector('iframe')).toBeNull();
+    unmount();
+    expect(viewer.destroy).toHaveBeenCalledOnce();
+  },
+);
+
+it('shows the denied content response without trying a third-party viewer', async () => {
+  vi.stubGlobal(
+    'fetch',
+    vi
+      .fn<typeof fetch>()
+      .mockResolvedValue(new Response(null, { status: 403 })),
+  );
+  render(
+    <FilePreviewDialog
+      files={[file('docx')]}
+      open
+      onOpenChange={vi.fn()}
+      download={false}
+    />,
+  );
+  expect(await screen.findByRole('alert')).toHaveTextContent('403');
+  expect(viewer.load).not.toHaveBeenCalled();
+  expect(document.querySelector('iframe')).toBeNull();
+  expect(screen.queryByRole('button', { name: /Download/ })).toBeNull();
+});