@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.11

package/src/flow/actions/__tests__/fieldLinkageRules.scopeDepth.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, expect, it, vi } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
-import { fieldLinkageRules } from '../linkageRules';
+import { fieldLinkageRules, linkageAssignField } from '../linkageRules';
 
 describe('fieldLinkageRules action - linkage scope metadata', () => {
   const targetCollection: any = {
@@ -868,6 +868,155 @@ describe('fieldLinkageRules action - linkage scope metadata', () => {
     expect(setFormValues).toHaveBeenCalledTimes(2);
   });
 
+  it('keeps row-scoped override patches editable after the target is user edited', async () => {
+    const store = {
+      roles: [{ uid: 'role-uid-1', name: 'existing' }],
+    };
+    const getAt = (path: Array<string | number>) => path.reduce((acc: any, seg) => acc?.[seg], store as any);
+    const setAt = (path: Array<string | number>, value: any) => {
+      let cur: any = store;
+      for (const seg of path.slice(0, -1)) {
+        cur = cur[seg];
+      }
+      cur[path[path.length - 1]] = value;
+    };
+    const editedKeys = new Set<string>();
+    const toKey = (path: Array<string | number>) => JSON.stringify(path);
+    const form = {
+      getFieldValue: (path: Array<string | number>) => getAt(path),
+    };
+    const formValueRuntime = {
+      canApplyOverrideValuePatch: vi.fn((path: Array<string | number>) => !editedKeys.has(toKey(path))),
+    };
+    const setFormValues = vi.fn(async (patches: Array<{ path: Array<string | number>; value: any }>) => {
+      for (const patch of patches) {
+        setAt(patch.path, patch.value);
+      }
+    });
+
+    const engine = new FlowEngine();
+    const rowFork = new FlowModel({ uid: 'role-override-row-fork', flowEngine: engine }) as any;
+    rowFork.context.defineProperty('fieldIndex', {
+      value: ['roles:0'],
+    });
+    rowFork.context.defineProperty('form', {
+      value: form,
+    });
+    rowFork.context.defineProperty('setFormValues', {
+      value: setFormValues,
+    });
+    rowFork.context.defineProperty('app', {
+      value: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+    });
+    rowFork.subModels = { items: [] };
+    rowFork.getAction = vi.fn((name: string) => {
+      if (name === 'linkageAssignField') {
+        return linkageAssignField;
+      }
+    });
+
+    const masterModel: any = {
+      uid: 'master-role-override-grid',
+      forks: new Set([rowFork]),
+    };
+    const rolesField: any = {
+      type: 'hasMany',
+      isAssociationField: () => true,
+      targetCollection: {
+        getField: (name: string) => ({ name, isAssociationField: () => false }),
+      },
+    };
+    const blockModel: any = {
+      collection: {
+        getField: (name: string) => (name === 'roles' ? rolesField : null),
+      },
+      formValueRuntime,
+    };
+    rowFork.context.defineProperty('blockModel', {
+      value: blockModel,
+    });
+    const gridModel: any = {
+      uid: 'grid-model-role-override-row',
+      context: {
+        blockModel,
+      },
+      getAction: vi.fn((name: string) => {
+        if (name === 'linkageAssignField') {
+          return linkageAssignField;
+        }
+      }),
+      __allModels: [],
+    };
+    const ctx: any = {
+      model: gridModel,
+      engine: {
+        forEachModel: (cb: (m: any) => void) => {
+          cb(masterModel);
+        },
+      },
+      flowKey: 'eventSettings',
+      inputArgs: {
+        source: 'user',
+        txId: 'tx-role-override-row',
+        changedPaths: [['roles', 0, 'uid']],
+      },
+      app: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+      resolveJsonTemplate: async (v: any) => v,
+    };
+    const makeParams = (value: string) => ({
+      value: [
+        {
+          key: `rule-${value}`,
+          title: `rule-${value}`,
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              name: 'linkageAssignField',
+              params: {
+                value: [
+                  {
+                    key: `r-${value}`,
+                    enable: true,
+                    targetPath: 'roles.name',
+                    mode: 'override',
+                    value,
+                    condition: { logic: '$and', items: [] },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    await fieldLinkageRules.handler(ctx, makeParams('role-uid-1'));
+    expect(store.roles[0].name).toBe('role-uid-1');
+
+    store.roles[0].uid = 'role-uid-2';
+    await fieldLinkageRules.handler(ctx, makeParams('role-uid-2'));
+    expect(store.roles[0].name).toBe('role-uid-2');
+    expect(setFormValues).toHaveBeenCalledTimes(2);
+
+    store.roles[0].name = 'manual';
+    store.roles[0].uid = 'role-uid-3';
+    editedKeys.add(toKey(['roles', 0, 'name']));
+    await fieldLinkageRules.handler(ctx, makeParams('role-uid-3'));
+
+    expect(store.roles[0].name).toBe('manual');
+    expect(setFormValues).toHaveBeenCalledTimes(2);
+    expect(formValueRuntime.canApplyOverrideValuePatch).toHaveBeenCalledWith(['roles', 0, 'name']);
+  });
+
   it('skips stale subtable row forks after the row has been removed', async () => {
     const setFormValues = vi.fn(async () => undefined);
     const defaultHandler = vi.fn((actionCtx: any, { addFormValuePatch }: any) => {

package/src/flow/actions/__tests__/linkageAssignField.legacy.test.ts

@@ -69,6 +69,72 @@ describe('linkage assign actions - legacy params', () => {
     expect(setProps).not.toHaveBeenCalledWith(fieldModel, { value: 'default-in-update' });
   });
 
+  it('linkageAssignField should mark override mode for field targets', async () => {
+    const fieldModel: any = { uid: 'f-override', fieldPath: 'a.b' };
+    const ctx: any = {
+      model: {
+        subModels: { grid: { subModels: { items: [fieldModel] } } },
+      },
+      engine: { getModel: vi.fn(() => ({ fieldPath: 'a.b' })) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override',
+          enable: true,
+          targetPath: 'a.b',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-value',
+        },
+      ],
+      setProps,
+    });
+
+    expect(setProps).toHaveBeenCalledTimes(1);
+    const [, props] = setProps.mock.calls[0];
+    expect(props).toMatchObject({
+      value: 'override-value',
+      __linkageAssignMode: 'override',
+    });
+  });
+
+  it('linkageAssignField should emit override patches for targets without form item models', async () => {
+    const ctx: any = {
+      model: { subModels: { grid: { subModels: { items: [] } } } },
+      engine: { getModel: vi.fn(() => null) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+    const addFormValuePatch = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-direct',
+          enable: true,
+          targetPath: 'user.name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-direct',
+        },
+      ],
+      setProps,
+      addFormValuePatch,
+    });
+
+    expect(setProps).not.toHaveBeenCalled();
+    expect(addFormValuePatch).toHaveBeenCalledWith({
+      path: 'user.name',
+      value: 'override-direct',
+      whenEmpty: false,
+      mode: 'override',
+    });
+  });
+
   it('subFormLinkageAssignField should apply legacy object params at runtime', () => {
     const forkModel: any = {
       uid: 'f1',
@@ -381,6 +447,75 @@ describe('linkage assign actions - legacy params', () => {
     expect(addFormValuePatch).toHaveBeenCalledTimes(1);
   });
 
+  it('subFormLinkageAssignField should skip override patch after user edits the target path', () => {
+    const ctx: any = {
+      model: {
+        uid: 'sub-form-override-path',
+        getAclActionName: vi.fn(() => 'create'),
+        context: {},
+        parent: {
+          getStepParams: (flowKey: string, stepKey: string) => {
+            if (flowKey === 'fieldSettings' && stepKey === 'init') {
+              return { fieldPath: 'M2M.M2M' };
+            }
+            return {};
+          },
+        },
+        subModels: { grid: { subModels: { items: [] } } },
+      },
+      engine: {
+        getModel: vi.fn(() => null),
+      },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const addFormValuePatch = vi.fn();
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-1',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-1',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+    expect(addFormValuePatch).toHaveBeenNthCalledWith(1, {
+      path: 'M2M.M2M.Name',
+      value: 'override-1',
+      whenEmpty: false,
+      mode: 'override',
+    });
+
+    ctx.inputArgs = {
+      source: 'user',
+      changedPaths: [['M2M', 'M2M', 'Name']],
+    };
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-2',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-2',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+  });
+
   it('linkageAssignField should evaluate RunJS value before assign', async () => {
     const fieldModel: any = { uid: 'f-runjs-assign', fieldPath: 'a.b' };
     const runjs = vi.fn(async () => ({ success: true, value: 'from-runjs' }));

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -27,12 +27,12 @@ describe('linkageRules hidden state propagation', () => {
     const hostModel: any = {
       uid: 'host',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       __allModels: [],
       setProps: vi.fn(),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -41,10 +41,22 @@ describe('linkageRules hidden state propagation', () => {
     const sameTargetModel: any = {
       uid: 'same-target',
       hidden: false,
-      context: { blockModel },
+      context: { blockModel, fieldPathArray: ['children'] },
       setProps: vi.fn(),
       getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
-        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        if (stepKey === 'init') return { fieldPath: 'children' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const nestedColumnModel: any = {
+      uid: 'nested-column',
+      hidden: true,
+      context: { blockModel, fieldPathArray: ['children'] },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'children.children' };
         return undefined;
       }),
       translate: (s: string) => s,
@@ -52,7 +64,7 @@ describe('linkageRules hidden state propagation', () => {
 
     const engine = {
       forEachModel: (visitor: (m: any) => void) => {
-        [hostModel, sameTargetModel].forEach(visitor);
+        [hostModel, sameTargetModel, nestedColumnModel].forEach(visitor);
       },
     };
 
@@ -92,9 +104,11 @@ describe('linkageRules hidden state propagation', () => {
     });
     expect(hostModel.hidden).toBe(true);
     expect(sameTargetModel.hidden).toBe(true);
+    expect(nestedColumnModel.hidden).toBe(true);
 
     await actionLinkageRules.handler(ctx, { value: [] });
     expect(hostModel.hidden).toBe(false);
     expect(sameTargetModel.hidden).toBe(false);
+    expect(nestedColumnModel.hidden).toBe(true);
   });
 });

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

@@ -728,6 +728,98 @@ describe('linkageSetFieldProps action', () => {
     expect(form.setFieldValue).not.toHaveBeenCalled();
   });
 
+  it('should not clear the parent field when a nested same-name field inherits the parent path', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (JSON.stringify(path) === JSON.stringify(['children', 'children'])) {
+          return [{ title: 'nested' }];
+        }
+        if (JSON.stringify(path) === JSON.stringify(['children'])) {
+          return [{ title: 'parent' }];
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'nested-children-field',
+      hidden: false,
+      context: {
+        form,
+        fieldPathArray: ['children'],
+      },
+      props: {
+        label: 'Children',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'children.children' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => (name === 'linkageSetFieldProps' ? linkageSetFieldProps : null),
+      resolveJsonTemplate: vi.fn(async (value) => value),
+    };
+
+    await fieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'action-1',
+              name: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['nested-children-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['children', 'children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(setFormValues).not.toHaveBeenCalledWith(
+      [{ path: ['children'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
   it('should keep hidden clear after same-round assignment for the same field', async () => {
     const formValues: { name?: string } = {};
     const setFormValues = vi.fn(async (patches: Array<{ path: Array<string | number>; value: string | undefined }>) => {

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

@@ -0,0 +1,171 @@
+/**
+ * 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 * as linkageActions from '../linkageRules';
+
+const tabLinkageRules = (linkageActions as Record<string, unknown>).tabLinkageRules as
+  | typeof linkageActions.menuLinkageRules
+  | undefined;
+const linkageSetTabProps = (linkageActions as Record<string, unknown>).linkageSetTabProps as
+  | typeof linkageActions.linkageSetMenuItemProps
+  | undefined;
+
+function createRuntime() {
+  let matched = true;
+  const setProps = vi.fn(function (this: { props: Record<string, unknown> }, props: Record<string, unknown>) {
+    this.props = {
+      ...this.props,
+      ...props,
+    };
+  });
+  const setHidden = vi.fn(function (this: { hidden: boolean }, value: boolean) {
+    this.hidden = value;
+  });
+  const model = {
+    uid: 'tab-1',
+    props: {} as Record<string, unknown>,
+    hidden: false,
+    __allModels: [],
+    setProps,
+    setHidden,
+  };
+  const ctx = {
+    app: { jsonLogic: { apply: () => matched } },
+    model,
+    t: (text: string) => text,
+    getAction: (name: string) => (name === 'linkageSetTabProps' ? linkageSetTabProps : undefined),
+    resolveJsonTemplate: vi.fn(async (value: unknown) => value),
+  };
+
+  return {
+    ctx,
+    model,
+    setMatched(value: boolean) {
+      matched = value;
+    },
+  };
+}
+
+const hideRule = {
+  value: [
+    {
+      key: 'rule-1',
+      title: 'Hide tab',
+      enable: true,
+      condition: {
+        logic: '$and',
+        items: [{ path: 'status', operator: '$eq', value: 'visible' }],
+      },
+      actions: [
+        {
+          key: 'action-1',
+          name: 'linkageSetTabProps',
+          params: { value: 'hidden' },
+        },
+      ],
+    },
+  ],
+};
+
+describe('tab linkage rules', () => {
+  it('should append the tab linkage scene without changing existing scene values', () => {
+    const scenes = ActionScene as unknown as Record<string, number>;
+
+    expect(scenes.MENU_LINKAGE_RULES).toBe(7);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(8);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(Math.max(...Object.values(scenes).filter(Number.isInteger)));
+  });
+
+  it('should register tab linkage actions from the actions entry', () => {
+    expect((registeredActions as Record<string, unknown>).tabLinkageRules).toBe(tabLinkageRules);
+    expect((registeredActions as Record<string, unknown>).linkageSetTabProps).toBe(linkageSetTabProps);
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+  });
+
+  it('should expose tab state and runjs actions in ui schema', () => {
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+
+    const schema = tabLinkageRules?.uiSchema?.({
+      getActions: () =>
+        new Map([
+          ['linkageSetTabProps', linkageSetTabProps],
+          ['linkageRunjs', linkageActions.linkageRunjs],
+          ['linkageSetMenuItemProps', linkageActions.linkageSetMenuItemProps],
+        ]),
+    } as never) as Record<string, Record<string, Record<string, unknown>>> | undefined;
+
+    expect(schema?.value?.['x-component-props']?.supportedActions).toEqual(['linkageSetTabProps', 'linkageRunjs']);
+    expect(linkageSetTabProps?.scene).toBe((ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES);
+    expect(linkageActions.linkageRunjs.scene).toContain(
+      (ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES,
+    );
+  });
+
+  it('should hide the tab when the condition matches and restore it when the condition misses', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should restore the tab when linkage rules are cleared', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should not restore stale tab props while applying or clearing visibility rules', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+    runtime.model.props = {
+      title: 'Original title',
+      icon: 'original-icon',
+      route: { options: { badge: 'original' } },
+    };
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    const updatedProps = {
+      title: 'Updated title',
+      icon: 'updated-icon',
+      route: { options: { badge: 'updated' } },
+    };
+    runtime.model.props = updatedProps;
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+  });
+});

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

@@ -135,11 +135,15 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-mounted'] });
   });
 
-  it('runs linkage action on master model when forks exist in design mode', async () => {
+  it('skips master model when forks can handle flow in design mode', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
-      forks: new Set([{}]),
+      forks: new Set([
+        {
+          getFlow: vi.fn(() => ({})),
+        },
+      ]),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn(() => ({ value: ['master'] })),
       context: {
@@ -157,7 +161,7 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
-    expect(handler).toHaveBeenCalledWith(ctx, { value: ['master'] });
+    expect(handler).not.toHaveBeenCalled();
   });
 
   it('runs linkage action on fork model and resolves params', async () => {