@nocobase/client-v2 2.1.0-alpha.32 → 2.1.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-alpha.32",
+  "version": "2.1.0-alpha.34",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,9 +24,9 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-alpha.32",
-    "@nocobase/sdk": "2.1.0-alpha.32",
-    "@nocobase/shared": "2.1.0-alpha.32",
+    "@nocobase/flow-engine": "2.1.0-alpha.34",
+    "@nocobase/sdk": "2.1.0-alpha.34",
+    "@nocobase/shared": "2.1.0-alpha.34",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
@@ -37,5 +37,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "1ba7d717e156651db17c615f9b9c48edd669d19b"
+  "gitHead": "59970f73bdbea2656e20cd24357bacf78a3f759f"
 }

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/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);
+  });
+});

package/src/flow/actions/__tests__/linkageRules.formValueDrivenRefresh.test.ts

@@ -26,7 +26,12 @@ function createRule(overrides: any = {}) {
 
 function createRuntime(
   params: any,
-  options: { fieldIndex?: string[]; fieldIndexRef?: { current: string[] }; actionHandler?: any; engineEmitter?: any } = {},
+  options: {
+    fieldIndex?: string[];
+    fieldIndexRef?: { current: string[] };
+    actionHandler?: any;
+    engineEmitter?: any;
+  } = {},
 ) {
   const formEmitter = new EventEmitter();
   const formBlock: any = {

package/src/flow/actions/__tests__/linkageRules.menu.test.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { ActionScene } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as registeredActions from '../index';
+import { linkageRunjs, linkageSetMenuItemProps, menuLinkageRules } from '../linkageRules';
+
+describe('menu linkage rules', () => {
+  it('should register menu linkage actions from the actions entry', () => {
+    expect(registeredActions.menuLinkageRules).toBe(menuLinkageRules);
+    expect(registeredActions.linkageSetMenuItemProps).toBe(linkageSetMenuItemProps);
+  });
+
+  it('should expose menu state and runjs actions in ui schema', () => {
+    const schema = menuLinkageRules.uiSchema?.({
+      getActions: () =>
+        new Map([
+          ['linkageSetMenuItemProps', linkageSetMenuItemProps],
+          ['linkageRunjs', linkageRunjs],
+          [
+            'actionOnly',
+            {
+              name: 'actionOnly',
+              scene: ActionScene.ACTION_LINKAGE_RULES,
+            },
+          ],
+        ]),
+    } as any) as any;
+
+    expect(schema?.value?.['x-component-props']?.supportedActions).toEqual(['linkageSetMenuItemProps', 'linkageRunjs']);
+  });
+
+  it('should set menu model hidden through common linkage handler', async () => {
+    const setProps = vi.fn(function (this: any, props: any) {
+      this.props = {
+        ...this.props,
+        ...props,
+      };
+    });
+    const setHidden = vi.fn(function (this: any, value: boolean) {
+      this.hidden = value;
+    });
+    const model: any = {
+      uid: 'menu-item-1',
+      props: {},
+      hidden: false,
+      __allModels: [],
+      setProps,
+      setHidden,
+    };
+    const ctx: any = {
+      app: { jsonLogic: { apply: () => true } },
+      model,
+      t: (text: string) => text,
+      getAction: (name: string) => (name === 'linkageSetMenuItemProps' ? linkageSetMenuItemProps : undefined),
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+    };
+
+    await menuLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'r1',
+          title: 'Hide menu item',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'a1',
+              name: 'linkageSetMenuItemProps',
+              params: {
+                value: 'hidden',
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(setHidden).toHaveBeenCalledWith(true);
+    expect(model.hidden).toBe(true);
+  });
+});

package/src/flow/actions/index.ts

@@ -42,9 +42,11 @@ export {
   detailsFieldLinkageRules,
   linkageSetDetailsFieldProps,
   actionLinkageRules,
+  menuLinkageRules,
   blockLinkageRules,
   linkageSetBlockProps,
   linkageSetActionProps,
+  linkageSetMenuItemProps,
   linkageSetFieldProps,
   subFormLinkageSetFieldProps,
   linkageAssignField,