@nocobase/client-v2 2.1.0-alpha.31 → 2.1.0-alpha.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-alpha.31",
+  "version": "2.1.0-alpha.33",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,17 +24,18 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-alpha.31",
-    "@nocobase/sdk": "2.1.0-alpha.31",
-    "@nocobase/shared": "2.1.0-alpha.31",
+    "@nocobase/flow-engine": "2.1.0-alpha.33",
+    "@nocobase/sdk": "2.1.0-alpha.33",
+    "@nocobase/shared": "2.1.0-alpha.33",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
     "dayjs": "^1.11.10",
     "i18next": "^22.4.9",
+    "json5": "^2.2.3",
     "lodash": "4.17.21",
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "e2bc6b461a9bfd336043069c3211c9c5b01ebcc3"
+  "gitHead": "64aaff11b9d9cab6890fb4835d7ae6933f2d3081"
 }

package/src/__tests__/nocobase-buildin-plugin-auth.test.tsx

@@ -8,13 +8,29 @@
  */
 
 import { createMockClient } from '@nocobase/client-v2';
-import { render, waitFor } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
 import { NocoBaseBuildInPlugin } from '../nocobase-buildin-plugin';
 
 describe('nocobase buildin plugin auth redirect', () => {
   const originalLocation = globalThis.window.location;
 
+  beforeEach(() => {
+    Object.defineProperty(globalThis.window, 'matchMedia', {
+      configurable: true,
+      value: vi.fn().mockImplementation((query: string) => ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+      })),
+    });
+  });
+
   afterEach(() => {
     Object.defineProperty(globalThis.window, 'location', {
       configurable: true,
@@ -92,7 +108,7 @@ describe('nocobase buildin plugin auth redirect', () => {
     });
   });
 
-  it('should redirect authenticated v2 admin root to legacy default page before layout render', async () => {
+  it('should render v2 admin root without redirecting to legacy default page', async () => {
     const replace = vi.fn();
     Object.defineProperty(globalThis.window, 'location', {
       configurable: true,
@@ -118,6 +134,7 @@ describe('nocobase buildin plugin auth redirect', () => {
       },
     });
     app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
+    app.apiMock.onGet('systemSettings:get').reply(200, { data: {} });
     app.apiMock.onGet('/desktopRoutes:listAccessible').reply(200, {
       data: [
         {
@@ -133,53 +150,57 @@ describe('nocobase buildin plugin auth redirect', () => {
     const { container } = render(<Root />);
 
     await waitFor(() => {
-      expect(replace).toHaveBeenCalledWith('/admin/legacy-page');
+      expect(container.innerHTML).toContain('No pages yet, please configure first');
     });
+    expect(replace).not.toHaveBeenCalled();
     expect(container.innerHTML).not.toContain('Legacy page');
   });
 
-  it('should redirect authenticated direct legacy v2 page access to v1 path', async () => {
-    const replace = vi.fn();
-    Object.defineProperty(globalThis.window, 'location', {
-      configurable: true,
-      value: {
-        ...originalLocation,
-        pathname: '/v2/admin/legacy-page/tab/tab-1',
-        search: '?from=direct',
-        hash: '#dialog',
-        replace,
-      },
-    });
-
-    const app = createMockClient({
-      publicPath: '/v2/',
-      plugins: [NocoBaseBuildInPlugin as any],
-      router: { type: 'memory', initialEntries: ['/v2/admin/legacy-page/tab/tab-1'] },
-    });
-    app.apiMock.onGet('app:getLang').reply(200, {
-      data: {
-        lang: 'en-US',
-        resources: { client: {} },
-        cron: {},
-      },
-    });
-    app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
-    app.apiMock.onGet('/desktopRoutes:listAccessible').reply(200, {
-      data: [
-        {
-          id: 1,
-          title: 'Legacy page',
-          schemaUid: 'legacy-page',
-          type: 'page',
+  it.each(['/v2/admin/legacy-page/tab/tab-1', '/v2/admin/legacy-page/view/detail'])(
+    'should show 404 for authenticated direct legacy v2 page access: %s',
+    async (pathname) => {
+      const replace = vi.fn();
+      Object.defineProperty(globalThis.window, 'location', {
+        configurable: true,
+        value: {
+          ...originalLocation,
+          pathname,
+          search: '?from=direct',
+          hash: '#dialog',
+          replace,
         },
-      ],
-    });
-
-    const Root = app.getRootComponent();
-    render(<Root />);
-
-    await waitFor(() => {
-      expect(replace).toHaveBeenCalledWith('/admin/legacy-page/tabs/tab-1?from=direct#dialog');
-    });
-  });
+      });
+
+      const app = createMockClient({
+        publicPath: '/v2/',
+        plugins: [NocoBaseBuildInPlugin as any],
+        router: { type: 'memory', initialEntries: [pathname] },
+      });
+      app.apiMock.onGet('app:getLang').reply(200, {
+        data: {
+          lang: 'en-US',
+          resources: { client: {} },
+          cron: {},
+        },
+      });
+      app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
+      app.apiMock.onGet('systemSettings:get').reply(200, { data: {} });
+      app.apiMock.onGet('/desktopRoutes:listAccessible').reply(200, {
+        data: [
+          {
+            id: 1,
+            title: 'Legacy page',
+            schemaUid: 'legacy-page',
+            type: 'page',
+          },
+        ],
+      });
+
+      const Root = app.getRootComponent();
+      render(<Root />);
+
+      expect(await screen.findByText('404')).toBeInTheDocument();
+      expect(replace).not.toHaveBeenCalled();
+    },
+  );
 });

package/src/__tests__/settings-center.test.tsx

@@ -158,6 +158,36 @@ describe('settings center', () => {
     expect(await screen.findByDisplayValue('NocoBase')).toBeInTheDocument();
   });
 
+  it('should expose current language variable as enabled-language selector', async () => {
+    const app = createMockClient({
+      plugins: [NocoBaseBuildInPlugin, TestAclPlugin],
+      router: { type: 'memory', initialEntries: ['/admin/settings/system-settings'] },
+    });
+    mockAdminRuntime(app, {
+      systemSettings: {
+        enabledLanguages: ['en-US', 'zh-CN'],
+      },
+    });
+
+    await renderApp(app);
+    await waitForGetRequests(app, ['/auth:check', 'roles:check', 'systemSettings:get']);
+
+    await waitFor(() => {
+      const localeNode = app.flowEngine.context.getPropertyMetaTree().find((node) => node.name === 'locale');
+      expect(localeNode).toMatchObject({
+        name: 'locale',
+        title: '{{t("Current language")}}',
+        interface: 'select',
+        uiSchema: {
+          enum: [
+            { label: 'English', value: 'en-US' },
+            { label: '简体中文', value: 'zh-CN' },
+          ],
+        },
+      });
+    });
+  });
+
   it('should fallback to plugin-manager when system-settings is not allowed', async () => {
     const app = createMockClient({
       plugins: [NocoBaseBuildInPlugin, TestAclPlugin],

package/src/components/form/JsonTextArea.tsx

@@ -0,0 +1,129 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { css, cx } from '@emotion/css';
+import { Input, Typography } from 'antd';
+import type { TextAreaProps } from 'antd/es/input';
+import JSON5 from 'json5';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+export interface JsonTextAreaProps extends Omit<TextAreaProps, 'value' | 'onChange'> {
+  value?: unknown;
+  onChange?: (value: unknown) => void;
+  space?: number;
+  json5?: boolean;
+  showError?: boolean;
+}
+
+const jsonTextAreaClassName = css`
+  font-size: 80%;
+  font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+`;
+
+function stringifyJsonValue(value: unknown, json: typeof JSON | typeof JSON5, space: number) {
+  if (value == null) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    try {
+      json.parse(value);
+      return value;
+    } catch {
+      return json.stringify(value, undefined, space);
+    }
+  }
+
+  return json.stringify(value, undefined, space);
+}
+
+export const JsonTextArea = React.memo((props: JsonTextAreaProps) => {
+  const {
+    value,
+    onChange,
+    space = 2,
+    json5 = false,
+    showError = true,
+    className,
+    status,
+    onBlur,
+    ...textAreaProps
+  } = props;
+  const json = json5 ? JSON5 : JSON;
+  const [text, setText] = useState(() => stringifyJsonValue(value, json, space));
+  const [error, setError] = useState<string>();
+
+  useEffect(() => {
+    setText(stringifyJsonValue(value, json, space));
+  }, [json, space, value]);
+
+  const parseText = useCallback(
+    (nextText: string) => {
+      if (nextText.trim() === '') {
+        return null;
+      }
+
+      return json.parse(nextText);
+    },
+    [json],
+  );
+
+  const handleChange = useCallback(
+    (event: React.ChangeEvent<HTMLTextAreaElement>) => {
+      const nextText = event.target.value;
+      setText(nextText);
+
+      try {
+        parseText(nextText);
+        setError(undefined);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    },
+    [parseText],
+  );
+
+  const handleBlur = useCallback(
+    (event: React.FocusEvent<HTMLTextAreaElement>) => {
+      try {
+        const parsed = parseText(event.target.value);
+        setError(undefined);
+        setText(parsed == null ? '' : json.stringify(parsed, undefined, space));
+        onChange?.(parsed);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+
+      onBlur?.(event);
+    },
+    [json, onBlur, onChange, parseText, space],
+  );
+
+  const mergedStatus = useMemo(() => status || (error ? 'error' : undefined), [error, status]);
+
+  return (
+    <>
+      <Input.TextArea
+        {...textAreaProps}
+        value={text}
+        onChange={handleChange}
+        onBlur={handleBlur}
+        status={mergedStatus}
+        className={cx(jsonTextAreaClassName, className)}
+      />
+      {showError && error ? (
+        <Typography.Text type="danger" style={{ display: 'block', marginTop: 4 }}>
+          {error}
+        </Typography.Text>
+      ) : null}
+    </>
+  );
+});
+
+JsonTextArea.displayName = 'JsonTextArea';

package/src/components/index.ts

@@ -10,4 +10,5 @@
 export * from './AppComponents';
 export * from './BlankComponent';
 export * from './Icon';
+export * from './form/JsonTextArea';
 export * from './RouterContextCleaner';

package/src/flow/__tests__/FlowRoute.test.tsx

@@ -10,7 +10,7 @@
 import React from 'react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MemoryRouter, Route, Routes } from 'react-router-dom';
-import { render, waitFor } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import { FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
 import FlowRoute from '../components/FlowRoute';
 
@@ -219,7 +219,7 @@ describe('FlowRoute', () => {
     });
   });
 
-  it('should replace to legacy page when current route is page', async () => {
+  it('should show 404 when current route is a legacy page in v2 runtime', async () => {
     const originalLocation = window.location;
     const replace = vi.fn();
     Object.defineProperty(window, 'location', {
@@ -271,9 +271,8 @@ describe('FlowRoute', () => {
         </FlowEngineProvider>,
       );
 
-      await waitFor(() => {
-        expect(replace).toHaveBeenCalledWith('/admin/test-page/tabs/tab-1?from=direct#dialog');
-      });
+      expect(await screen.findByText('404')).toBeInTheDocument();
+      expect(replace).not.toHaveBeenCalled();
       expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
       expect(adminLayoutModel.updateRoutePage).not.toHaveBeenCalled();
     } finally {

package/src/flow/actions/__tests__/actionLinkageRules.race.repro.test.ts

@@ -0,0 +1,199 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { actionLinkageRules } from '../linkageRules';
+
+function createActionModel() {
+  const model: any = {
+    uid: 'edit-action',
+    hidden: false,
+    props: {
+      title: 'Edit',
+    },
+    context: {},
+    setProps: vi.fn((keyOrProps: string | Record<string, any>, value?: any) => {
+      if (typeof keyOrProps === 'string') {
+        model.props[keyOrProps] = value;
+        return;
+      }
+      model.props = {
+        ...model.props,
+        ...keyOrProps,
+      };
+    }),
+  };
+
+  return model;
+}
+
+function createLinkageParams(actions: any[] = []) {
+  return {
+    value: actions.length
+      ? [
+          {
+            key: 'hide-edit',
+            title: 'hide edit',
+            enable: true,
+            condition: {
+              logic: '$and',
+              items: [],
+            },
+            actions,
+          },
+        ]
+      : [],
+  };
+}
+
+function createRuntime(model: any, options: { pauseHiddenAction?: boolean } = {}) {
+  const { pauseHiddenAction = true } = options;
+  let releaseHiddenAction: () => void = () => {};
+  let hiddenActionCount = 0;
+  const hiddenActionWaiters: Array<{ count: number; resolve: () => void }> = [];
+  const waitForHiddenActionCount = (count: number) => {
+    if (hiddenActionCount >= count) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      hiddenActionWaiters.push({ count, resolve });
+    });
+  };
+  const hiddenActionReachedPromise = waitForHiddenActionCount(1);
+  const releaseHiddenActionPromise = new Promise<void>((resolve) => {
+    releaseHiddenAction = resolve;
+  });
+  const notifyHiddenActionReached = () => {
+    hiddenActionCount += 1;
+    for (let i = hiddenActionWaiters.length - 1; i >= 0; i--) {
+      const waiter = hiddenActionWaiters[i];
+      if (hiddenActionCount < waiter.count) continue;
+      hiddenActionWaiters.splice(i, 1);
+      waiter.resolve();
+    }
+  };
+
+  const ctx: any = {
+    flowKey: 'buttonSettings',
+    model,
+    app: {
+      jsonLogic: {
+        apply: vi.fn(() => true),
+      },
+    },
+    t: (s: string) => s,
+    resolveJsonTemplate: vi.fn(async (value: any) => value),
+    getAction: (name: string) => {
+      if (name !== 'linkageSetActionProps') return undefined;
+
+      return {
+        handler: async (_ctx: any, params: any) => {
+          params.setProps(model, {
+            hiddenModel: params.value === 'hidden',
+            disabled: false,
+            hiddenText: false,
+          });
+          notifyHiddenActionReached();
+          if (pauseHiddenAction) {
+            await releaseHiddenActionPromise;
+          }
+        },
+      };
+    },
+  };
+
+  return {
+    ctx,
+    hiddenActionReachedPromise,
+    waitForHiddenActionCount,
+    releaseHiddenAction,
+  };
+}
+
+describe('actionLinkageRules props patch isolation', () => {
+  async function runReproOnce() {
+    const model = createActionModel();
+    const { ctx, hiddenActionReachedPromise, releaseHiddenAction } = createRuntime(model);
+
+    const hideRun = actionLinkageRules.handler(
+      ctx,
+      createLinkageParams([
+        {
+          name: 'linkageSetActionProps',
+          params: {
+            value: 'hidden',
+          },
+        },
+      ]),
+    );
+
+    await hiddenActionReachedPromise;
+    expect(model.hidden).toBe(false);
+
+    await actionLinkageRules.handler(ctx, createLinkageParams());
+    expect(model.hidden).toBe(false);
+
+    releaseHiddenAction();
+    await hideRun;
+
+    expect(model.hidden).toBe(true);
+  }
+
+  it('keeps a concurrent empty run from clearing another run props patch', async () => {
+    for (let i = 0; i < 50; i++) {
+      await runReproOnce();
+    }
+  });
+
+  it('still restores original props when a later completed run has no matched actions', async () => {
+    const model = createActionModel();
+    const { ctx } = createRuntime(model, { pauseHiddenAction: false });
+
+    await actionLinkageRules.handler(
+      ctx,
+      createLinkageParams([
+        {
+          name: 'linkageSetActionProps',
+          params: {
+            value: 'hidden',
+          },
+        },
+      ]),
+    );
+    expect(model.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, createLinkageParams());
+    expect(model.hidden).toBe(false);
+  });
+
+  it('keeps concurrent matched runs from clearing each other props patch', async () => {
+    const model = createActionModel();
+    const { ctx, waitForHiddenActionCount, releaseHiddenAction } = createRuntime(model);
+    const params = createLinkageParams([
+      {
+        name: 'linkageSetActionProps',
+        params: {
+          value: 'hidden',
+        },
+      },
+    ]);
+
+    const firstRun = actionLinkageRules.handler(ctx, params);
+    await waitForHiddenActionCount(1);
+
+    const secondRun = actionLinkageRules.handler(ctx, params);
+    await waitForHiddenActionCount(2);
+
+    releaseHiddenAction();
+    await firstRun;
+    await secondRun;
+
+    expect(model.hidden).toBe(true);
+  });
+});