@nocobase/client-v2 2.3.0-alpha.1 → 2.3.0-beta.11

package/src/flow/actions/__tests__/actionLinkageRules.forkProps.test.ts

@@ -0,0 +1,314 @@
+/**
+ * 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 { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { ActionModel as ConfiguredActionModel } from '../../models/base/ActionModel';
+import { ActionModel } from '../../models/base/ActionModelCore';
+import { actionLinkageRules, linkageSetActionProps, updateLinkageRules } from '../linkageRules';
+
+class TestActionModel extends ActionModel {}
+
+describe('action linkage rules on action forks', () => {
+  it('does not snapshot unrelated master props when disabling an action', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TestActionModel });
+    const master = engine.createModel<TestActionModel>({
+      use: 'TestActionModel',
+      props: { title: 'Edit' },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    const ctx = {
+      flowKey: 'buttonSettings',
+      model: fork,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      t: (value: string) => value,
+      resolveJsonTemplate: vi.fn(async (value: unknown) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: unknown, params: { setProps: Function }) => {
+            params.setProps(fork, { disabled: true });
+          },
+        };
+      },
+    } as never;
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'disable-edit',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+        },
+      ],
+    });
+
+    expect(fork.localProps.title).toBeUndefined();
+    expect(fork.__originalProps.title).toBeUndefined();
+    expect(fork.localProps.disabled).toBe(true);
+
+    master.setProps('title', 'Updated');
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'disable-edit',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+        },
+      ],
+    });
+
+    expect(fork.getProps().title).toBe('Updated');
+    expect(fork.serialize().props).toMatchObject({ title: 'Updated' });
+    expect(fork.serialize().props).not.toHaveProperty('disabled');
+
+    const refreshedFork = master.createFork({ className: 'row-action' });
+    expect(refreshedFork.getProps().title).toBe('Updated');
+  });
+
+  it.each(['disable', 'delete'] as const)(
+    'restores a row action when linkage rules are %sd without persisting disabled',
+    async (change) => {
+      const engine = new FlowEngine();
+      engine.registerModels({ ConfiguredActionModel });
+      engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+
+      let savedData: ReturnType<ConfiguredActionModel['serialize']> | undefined;
+      engine.setModelRepository({
+        save: async (model) => {
+          savedData = model.serialize();
+          return savedData;
+        },
+      } as Parameters<FlowEngine['setModelRepository']>[0]);
+
+      const enabledRules = [
+        {
+          key: 'disable-edit',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+        },
+      ];
+      const master = engine.createModel<ConfiguredActionModel>({
+        use: 'ConfiguredActionModel',
+        props: { title: 'Edit' },
+        stepParams: {
+          buttonSettings: {
+            linkageRules: { value: enabledRules },
+          },
+        },
+      });
+      const fork = master.createFork({ className: 'row-action' });
+
+      await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+      expect(fork.getProps().disabled).toBe(true);
+
+      const nextRules =
+        change === 'disable'
+          ? updateLinkageRules(enabledRules, (rules) => {
+              rules[0].enable = false;
+            })
+          : [];
+      fork.setStepParams('buttonSettings', 'linkageRules', { value: nextRules });
+      await fork.saveStepParams();
+      await fork.rerender();
+
+      expect(savedData).toBeDefined();
+      expect(savedData?.props).not.toHaveProperty('disabled');
+      expect(savedData?.stepParams.buttonSettings.linkageRules.value).toEqual(nextRules);
+      expect(fork.getProps().disabled).toBeUndefined();
+
+      const reloadedEngine = new FlowEngine();
+      reloadedEngine.registerModels({ ConfiguredActionModel });
+      reloadedEngine.registerActions({ actionLinkageRules, linkageSetActionProps });
+      const reloadedMaster = reloadedEngine.createModel<ConfiguredActionModel>({
+        use: 'ConfiguredActionModel',
+        props: savedData?.props,
+        stepParams: savedData?.stepParams,
+      });
+      const reloadedFork = reloadedMaster.createFork({ className: 'row-action' });
+
+      await reloadedFork.dispatchEvent('beforeRender', undefined, { useCache: false });
+      expect(reloadedFork.getProps().disabled).toBeUndefined();
+    },
+  );
+
+  it.each(['disabled', 'deleted'] as const)(
+    'ignores a historical disabled prop after the linkage rule is %s',
+    async (state) => {
+      const engine = new FlowEngine();
+      engine.registerModels({ ConfiguredActionModel });
+      engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+      const rules =
+        state === 'disabled'
+          ? [
+              {
+                key: 'disable-edit',
+                enable: false,
+                condition: { logic: '$and', items: [] },
+                actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+              },
+            ]
+          : [];
+      const master = engine.createModel<ConfiguredActionModel>({
+        use: 'ConfiguredActionModel',
+        props: { title: 'Edit', disabled: true },
+        stepParams: {
+          buttonSettings: {
+            linkageRules: { value: rules },
+          },
+        },
+      });
+      const fork = master.createFork({ className: 'row-action' });
+
+      expect(master.getProps()).not.toHaveProperty('disabled');
+      await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+
+      expect(fork.getProps().disabled).toBeUndefined();
+    },
+  );
+
+  it('still applies an enabled linkage rule after dropping a historical disabled prop', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ ConfiguredActionModel });
+    engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+    const master = engine.createModel<ConfiguredActionModel>({
+      use: 'ConfiguredActionModel',
+      props: { title: 'Edit', disabled: true },
+      stepParams: {
+        buttonSettings: {
+          linkageRules: {
+            value: [
+              {
+                key: 'disable-edit',
+                enable: true,
+                condition: { logic: '$and', items: [] },
+                actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+              },
+            ],
+          },
+        },
+      },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    expect(master.getProps()).not.toHaveProperty('disabled');
+    await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+
+    expect(fork.getProps().disabled).toBe(true);
+  });
+
+  it('preserves a default disabled state as runtime-only state', async () => {
+    class DefaultDisabledActionModel extends ConfiguredActionModel {
+      defaultProps = { ...this.defaultProps, disabled: true };
+    }
+    const engine = new FlowEngine();
+    engine.registerModels({ DefaultDisabledActionModel });
+    engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+    const master = engine.createModel<DefaultDisabledActionModel>({
+      use: 'DefaultDisabledActionModel',
+      props: { title: 'Edit' },
+      stepParams: {
+        buttonSettings: {
+          linkageRules: { value: [] },
+        },
+      },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+
+    expect(fork.getProps().disabled).toBe(true);
+    expect(fork.serialize().props).not.toHaveProperty('disabled');
+  });
+
+  it('updates a disabled row action title through the real beforeRender flow', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ ConfiguredActionModel });
+    engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+    let savedData: ReturnType<ConfiguredActionModel['serialize']> | undefined;
+    engine.setModelRepository({
+      save: async (model) => {
+        savedData = model.serialize();
+        return savedData;
+      },
+    } as Parameters<FlowEngine['setModelRepository']>[0]);
+    const master = engine.createModel<ConfiguredActionModel>({
+      use: 'ConfiguredActionModel',
+      props: { title: 'Edit' },
+      stepParams: {
+        buttonSettings: {
+          general: { title: 'Edit' },
+          linkageRules: {
+            value: [
+              {
+                key: 'disable-edit',
+                enable: true,
+                condition: { logic: '$and', items: [] },
+                actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+              },
+            ],
+          },
+        },
+      },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+    expect(fork.getProps()).toMatchObject({ title: 'Edit', disabled: true });
+
+    fork.setStepParams('buttonSettings', 'general', { title: 'Updated' });
+    await fork.saveStepParams();
+    await fork.rerender();
+
+    expect(savedData?.props).not.toHaveProperty('disabled');
+    expect(savedData?.stepParams.buttonSettings.general.title).toBe('Updated');
+    expect(fork.getProps()).toMatchObject({ title: 'Updated', disabled: true });
+
+    const reloadedEngine = new FlowEngine();
+    reloadedEngine.registerModels({ ConfiguredActionModel });
+    reloadedEngine.registerActions({ actionLinkageRules, linkageSetActionProps });
+    const reloadedMaster = reloadedEngine.createModel<ConfiguredActionModel>({
+      use: 'ConfiguredActionModel',
+      props: savedData?.props,
+      stepParams: savedData?.stepParams,
+    });
+    const reloadedFork = reloadedMaster.createFork({ className: 'row-action' });
+
+    await reloadedFork.dispatchEvent('beforeRender', undefined, { useCache: false });
+    expect(reloadedFork.getProps()).toMatchObject({ title: 'Updated', disabled: true });
+  });
+
+  it('creates a new rules value when disabling a linkage rule', () => {
+    const rules = [
+      {
+        key: 'disable-edit',
+        title: 'Linkage rule',
+        enable: true,
+        condition: { logic: '$and', items: [] },
+        actions: [],
+      },
+    ];
+    const nextRules = updateLinkageRules(rules, (next) => {
+      next[0].enable = false;
+    });
+
+    expect(nextRules).toEqual([expect.objectContaining({ key: 'disable-edit', enable: false })]);
+    expect(nextRules).not.toBe(rules);
+    expect(rules[0].enable).toBe(true);
+  });
+});

package/src/flow/actions/__tests__/dataScopeFormValueClear.test.ts

@@ -225,6 +225,108 @@ describe('ensureFormValueDrivenDataScopeClear', () => {
     expect(onChange).toHaveBeenCalledWith(null);
   });
 
+  it('does not clear a popup form field when data scope depends on the external parent item', () => {
+    const emitter = new EventEmitter();
+    const formBlock = {
+      uid: 'form-1',
+      disposed: false,
+      emitter,
+      context: {
+        form: {},
+        formValues: { staff_m2o: null },
+      },
+    };
+
+    const onChange = vi.fn();
+    const model: any = {
+      disposed: false,
+      props: {
+        value: { id: 10 },
+        onChange,
+      },
+      context: {
+        blockModel: formBlock,
+      },
+    };
+
+    const ctx: any = {
+      model,
+      flowKey: 'selectSettings',
+    };
+
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'orgId', operator: '$eq', value: '{{ ctx.item.parentItem.value.org_m2o.id }}' }],
+    };
+
+    ensureFormValueDrivenDataScopeClear(ctx, filter);
+
+    emitter.emit('formValuesChange', {
+      changedPaths: [['staff_m2o']],
+      allValues: { staff_m2o: { id: 10 } },
+    });
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('maps popup current item dependencies to the popup form root', () => {
+    const emitter = new EventEmitter();
+    const formBlock = {
+      uid: 'form-1',
+      disposed: false,
+      emitter,
+      context: {
+        form: {},
+        formValues: {
+          org_m2o: { id: 1 },
+          staff_m2o: { id: 10 },
+        },
+      },
+    };
+
+    const onChange = vi.fn();
+    const model: any = {
+      disposed: false,
+      props: {
+        value: { id: 10 },
+        onChange,
+      },
+      context: {
+        blockModel: formBlock,
+      },
+    };
+
+    const ctx: any = {
+      model,
+      flowKey: 'selectSettings',
+    };
+
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'orgId', operator: '$eq', value: '{{ ctx.item.value.org_m2o.id }}' }],
+    };
+
+    ensureFormValueDrivenDataScopeClear(ctx, filter);
+
+    emitter.emit('formValuesChange', {
+      changedPaths: [['staff_m2o']],
+      allValues: {
+        org_m2o: { id: 1 },
+        staff_m2o: { id: 10 },
+      },
+    });
+    expect(onChange).not.toHaveBeenCalled();
+
+    emitter.emit('formValuesChange', {
+      changedPaths: [['org_m2o']],
+      allValues: {
+        org_m2o: { id: 2 },
+        staff_m2o: { id: 10 },
+      },
+    });
+    expect(onChange).toHaveBeenCalledWith(null);
+  });
+
   it('does not clear a row field when a sibling field changes but the item dependency value is unchanged', () => {
     const emitter = new EventEmitter();
     const formBlock = {

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

@@ -0,0 +1,33 @@
+/**
+ * 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 } from 'vitest';
+import { getActionLinkageStateOptions } from '../linkageRules';
+
+describe('getActionLinkageStateOptions', () => {
+  const t = (key: string) => key;
+
+  it('returns all states for regular action models', () => {
+    expect(getActionLinkageStateOptions({}, t).map((option) => option.value)).toEqual([
+      'visible',
+      'hidden',
+      'hiddenText',
+      'enabled',
+      'disabled',
+    ]);
+  });
+
+  it('filters states declared unsupported by the action model', () => {
+    expect(
+      getActionLinkageStateOptions({ supportedActionLinkageStates: ['visible', 'hidden'] }, t).map(
+        (option) => option.value,
+      ),
+    ).toEqual(['visible', 'hidden']);
+  });
+});

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

@@ -18,6 +18,7 @@ import {
   subFormFieldLinkageRules,
   subFormLinkageSetFieldProps,
 } from '../linkageRules';
+import { CreateFormModel, EditFormModel, FormGridModel, FormItemModel, JSItemModel } from '../../models';
 
 const createSubFormFieldModel = ({
   uid,
@@ -1056,6 +1057,77 @@ describe('linkageSetFieldProps action', () => {
     expect(await screen.findByText('Published')).toBeTruthy();
   });
 
+  it.each([
+    ['create form', CreateFormModel, linkageSetFieldProps, false],
+    ['edit form', EditFormModel, linkageSetFieldProps, false],
+    ['to-one subform', FlowModel, subFormLinkageSetFieldProps, false],
+    ['to-many subform row', FlowModel, subFormLinkageSetFieldProps, true],
+  ])('should exclude JS items from %s field state options', async (_, ModelClass, action, useGridFork) => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      CreateFormModel,
+      EditFormModel,
+      FormGridModel,
+      FormItemModel,
+      JSItemModel,
+    });
+    const model = new ModelClass({
+      flowEngine: engine,
+      uid: 'form-model',
+      use: ModelClass.name,
+    }) as FlowModel;
+    const grid = engine.createModel<FormGridModel>({
+      use: 'FormGridModel',
+      uid: 'form-grid',
+    });
+    const fieldModel = engine.createModel<FormItemModel>({
+      use: 'FormItemModel',
+      uid: 'name-field',
+      props: { label: 'Name' },
+      subModels: {
+        field: {
+          use: 'FlowModel',
+          uid: 'name-field-component',
+        },
+      },
+    });
+    const jsItemModel = engine.createModel<JSItemModel>({
+      use: 'JSItemModel',
+      uid: 'js-item',
+      props: { label: 'JS item' },
+    });
+    Object.assign(model.subModels, {
+      grid: useGridFork
+        ? grid.createFork({}, 'row-0')
+        : Object.assign(grid, {
+            subModels: {
+              ...grid.subModels,
+              items: [fieldModel, jsItemModel],
+            },
+          }),
+    });
+    Object.assign(model.subModels.grid.subModels, {
+      items: [fieldModel, jsItemModel],
+    });
+    const ctx = model.context;
+    const Comp: any = action.uiSchema.value['x-component'];
+    const view = render(
+      React.createElement(
+        FlowSettingsContextProvider,
+        { value: ctx },
+        React.createElement(Comp, {
+          value: { fields: [] },
+          onChange: () => {},
+        }),
+      ),
+    );
+
+    fireEvent.mouseDown(view.container.querySelector('.ant-select-selector') as Element);
+
+    expect(await screen.findByText('Name')).toBeTruthy();
+    expect(screen.queryByText('JS item')).toBeNull();
+  });
+
   it('should only show options state for supported single field selection', () => {
     const supportedField: any = {
       uid: 'status-field',

package/src/flow/actions/__tests__/validation.test.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 { validation } from '../validation';
+
+vi.mock('../../../flow-compat', () => ({ FieldValidation: () => null }));
+
+describe('validation action', () => {
+  it('rejects excess decimal places with a translated error and retains collection rules', async () => {
+    const setProps = vi.fn();
+    const collectionRule = { validator: vi.fn().mockResolvedValue(undefined) };
+    const t = vi.fn((key: string, options?: Record<string, unknown>) => {
+      return `${options?.label} 精度不能超过 ${options?.limit} 位小数`;
+    });
+    const ctx = {
+      model: {
+        props: { label: '工龄' },
+        collectionField: { getComponentProps: () => ({ rules: [collectionRule] }) },
+        setProps,
+      },
+      t,
+    } as unknown as Parameters<typeof validation.handler>[0];
+
+    await validation.handler(ctx, {
+      validation: { type: 'number', rules: [{ name: 'precision', args: { limit: 2 } }] },
+    });
+
+    const { rules } = setProps.mock.calls[0][0] as {
+      rules: { validator: (rule: unknown, value: unknown) => Promise<void> }[];
+    };
+    expect(rules).toHaveLength(2);
+    expect(rules[0]).toBe(collectionRule);
+    await expect(rules[1].validator({}, 39.2234)).rejects.toBe('工龄 精度不能超过 2 位小数');
+    expect(t).toHaveBeenCalledWith(
+      'number.precision',
+      expect.objectContaining({ ns: 'data-source-main', label: '工龄', limit: 2 }),
+    );
+    await expect(rules[1].validator({}, 39.22)).resolves.toBeUndefined();
+    await expect(rules[1].validator({}, null)).resolves.toBeUndefined();
+  });
+});