@nocobase/client-v2 2.1.0-alpha.45 → 2.1.0-alpha.47

package/src/components/form/filter/FilterValueInput.tsx

@@ -13,6 +13,10 @@ import type { FilterOperator, FilterOption } from '../../../flow/components/filt
 import { PasswordInput } from '../PasswordInput';
 import { DateFilterDynamicComponent } from './DateFilterDynamicComponent';
 
+type ComponentRegistryApp = {
+  getComponent?: (name: string) => React.ComponentType<any> | undefined;
+};
+
 export interface FilterValueInputProps {
   /** The currently selected leaf field option from the field picker. */
   field?: FilterOption;
@@ -26,17 +30,20 @@ export interface FilterValueInputProps {
   t?: (key: string) => string;
   /** Optional placeholder for the fallback `Input`. */
   placeholder?: string;
+  /** Optional v2 app registry used to resolve plugin-provided operator components. */
+  app?: ComponentRegistryApp;
 }
 
 const identity = (s: string) => s;
 
 type EffectiveSchema = {
-  'x-component'?: string;
+  'x-component'?: string | React.ComponentType<any>;
   'x-component-props'?: Record<string, any>;
   enum?: Array<{ value: any; label: string }> | any[];
 };
 
 const baseStyle = { minWidth: 200 } as const;
+const fallbackInputComponents = new Set(['Input', 'Input.URL', 'NanoIDInput']);
 
 /** Resolve operator-level schema → field uiSchema → fallback Input. */
 const resolveSchema = (field?: FilterOption, operator?: FilterOperator): EffectiveSchema => {
@@ -54,7 +61,7 @@ const resolveSchema = (field?: FilterOption, operator?: FilterOperator): Effecti
  * Interface-aware value renderer for filter rows. Returns `null` for `noValue` operators (`$empty`, `$notEmpty`). Otherwise dispatches the effective `x-component` (operator schema > field uiSchema > Input) to a small registry of antd controls.
  */
 export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
-  const { field, operator, value, onChange, t = identity, placeholder } = props;
+  const { field, operator, value, onChange, t = identity, placeholder, app } = props;
 
   if (operator?.noValue) {
     return null;
@@ -64,6 +71,12 @@ export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
   const componentName = schema['x-component'];
   const componentProps = schema['x-component-props'] || {};
   const enumOptions = (schema as any).enum || (field?.schema as any)?.enum;
+  const customComponentProps = {
+    value,
+    onChange,
+    ...componentProps,
+    style: { ...baseStyle, ...(componentProps.style || {}) },
+  };
 
   switch (componentName) {
     case 'DateFilterDynamicComponent':
@@ -183,6 +196,18 @@ export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
     case 'Input.URL':
     case 'NanoIDInput':
     default:
+      if (typeof componentName === 'function') {
+        const Component = componentName;
+        return <Component {...customComponentProps} />;
+      }
+
+      if (typeof componentName === 'string' && !fallbackInputComponents.has(componentName)) {
+        const Component = app?.getComponent?.(componentName);
+        if (Component) {
+          return <Component {...customComponentProps} />;
+        }
+      }
+
       return (
         <Input
           value={value}

package/src/components/form/filter/__tests__/FilterValueInput.test.tsx

@@ -222,6 +222,45 @@ describe('FilterValueInput schema precedence', () => {
     expect(document.querySelector('.ant-select')).not.toBeNull();
   });
 
+  it('operator schema can render an app-registered custom component', () => {
+    const onChange = vi.fn();
+    const CustomFilterInput = (props: any) => (
+      <button
+        type="button"
+        data-testid="custom-filter-input"
+        data-field-interface={props.fieldInterface}
+        data-value={JSON.stringify(props.value)}
+        onClick={() => props.onChange?.(['alpha', 'beta'])}
+      >
+        custom-filter-input
+      </button>
+    );
+
+    render(
+      <FilterValueInput
+        operator={opOf({
+          value: '$in',
+          schema: {
+            'x-component': 'MultipleKeywordsInput',
+            'x-component-props': { fieldInterface: 'input' },
+          },
+        })}
+        value={['foo', 'bar']}
+        onChange={onChange}
+        app={{
+          getComponent: (name) => (name === 'MultipleKeywordsInput' ? CustomFilterInput : undefined),
+        }}
+      />,
+    );
+
+    const input = screen.getByTestId('custom-filter-input');
+    expect(input.getAttribute('data-field-interface')).toBe('input');
+    expect(input.getAttribute('data-value')).toBe(JSON.stringify(['foo', 'bar']));
+
+    fireEvent.click(input);
+    expect(onChange).toHaveBeenCalledWith(['alpha', 'beta']);
+  });
+
   it('field uiSchema is used when operator has none', () => {
     const { container } = render(
       <FilterValueInput

package/src/components/form/index.tsx

@@ -16,4 +16,5 @@ export * from './FileSizeInput';
 export * from './JsonTextArea';
 export * from './PasswordInput';
 export * from './RemoteSelect';
+export * from './TypedVariableInput';
 export * from './VariableInput';

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

@@ -8,7 +8,7 @@
  */
 
 import React from 'react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { MemoryRouter, Route, Routes } from 'react-router-dom';
 import { render, screen, waitFor } from '@testing-library/react';
 import { FlowContextProvider, FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
@@ -32,6 +32,13 @@ describe('FlowRoute', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     hookState.refresh = vi.fn();
+    // Fixtures mount the modern client under the `v2` segment; tell the
+    // runtime-prefix helper so v2-runtime detection matches.
+    (globalThis.window as any).__nocobase_modern_client_prefix__ = 'v2';
+  });
+
+  afterEach(() => {
+    delete (globalThis.window as any).__nocobase_modern_client_prefix__;
   });
 
   it('should bridge page lifecycle to admin-layout-model', async () => {

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

@@ -0,0 +1,100 @@
+/**
+ * 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 createRule(actions: any[]) {
+  return {
+    key: 'r1',
+    title: 'r1',
+    enable: true,
+    condition: { logic: '$and', items: [] },
+    actions,
+  };
+}
+
+describe('linkageRules hidden state propagation', () => {
+  it('restores hidden state to same-target models when reverting to original props', async () => {
+    const blockModel = { uid: 'block-1' };
+
+    const hostModel: any = {
+      uid: 'host',
+      hidden: false,
+      context: { blockModel },
+      __allModels: [],
+      setProps: vi.fn(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const sameTargetModel: any = {
+      uid: 'same-target',
+      hidden: false,
+      context: { blockModel },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const engine = {
+      forEachModel: (visitor: (m: any) => void) => {
+        [hostModel, sameTargetModel].forEach(visitor);
+      },
+    };
+
+    const ctx: any = {
+      flowKey: 'buttonSettings',
+      model: hostModel,
+      engine,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: any, params: any) => {
+            params.setProps(hostModel, {
+              hiddenModel: params.value === 'hidden',
+              disabled: false,
+              hiddenText: false,
+            });
+          },
+        };
+      },
+    };
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        createRule([
+          {
+            name: 'linkageSetActionProps',
+            params: { value: 'hidden' },
+          },
+        ]),
+      ],
+    });
+    expect(hostModel.hidden).toBe(true);
+    expect(sameTargetModel.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, { value: [] });
+    expect(hostModel.hidden).toBe(false);
+    expect(sameTargetModel.hidden).toBe(false);
+  });
+});

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

@@ -9,9 +9,15 @@
 
 import React from 'react';
 import { fireEvent, render, screen } from '@testing-library/react';
-import { FlowSettingsContextProvider } from '@nocobase/flow-engine';
+import { FlowEngine, FlowModel, FlowSettingsContextProvider } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
-import { fieldLinkageRules, linkageSetFieldProps, subFormLinkageSetFieldProps } from '../linkageRules';
+import {
+  fieldLinkageRules,
+  linkageAssignField,
+  linkageSetFieldProps,
+  subFormFieldLinkageRules,
+  subFormLinkageSetFieldProps,
+} from '../linkageRules';
 
 const createSubFormFieldModel = ({
   uid,
@@ -335,6 +341,110 @@ describe('subFormLinkageSetFieldProps action', () => {
     expect(row0CollectedModel.hidden).toBe(false);
     expect(row1CollectedModel.hidden).toBe(true);
   });
+
+  it('should clear the current row value when a subform list field is hidden without reserving value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (JSON.stringify(path) === JSON.stringify(['items', 0, 'a'])) {
+          return 'row value';
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const engine = new FlowEngine();
+
+    const rowGridFork = new FlowModel({ uid: 'row-grid-fork', flowEngine: engine }) as any;
+    rowGridFork.hidden = false;
+    rowGridFork.context.defineProperty('fieldKey', { value: ['items:0'] });
+    rowGridFork.context.defineProperty('fieldIndex', { value: ['items:0'] });
+    rowGridFork.context.defineProperty('form', { value: form });
+    rowGridFork.context.defineProperty('setFormValues', { value: setFormValues });
+    rowGridFork.context.defineProperty('app', {
+      value: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+    });
+    rowGridFork.getAction = vi.fn((name: string) => {
+      if (name === 'subFormLinkageSetFieldProps') {
+        return subFormLinkageSetFieldProps;
+      }
+    });
+
+    const targetFieldFork: any = {
+      uid: 'field-a',
+      isFork: true,
+      hidden: false,
+      props: {},
+      context: {
+        fieldIndex: ['items:0'],
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'a' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+
+    const formItemModel: any = {
+      uid: 'field-a',
+      getFork: vi.fn((key: string) => (key === 'items:0:field-a' ? targetFieldFork : undefined)),
+    };
+
+    engine.getModel = vi.fn((uid: string) => (uid === 'field-a' ? formItemModel : undefined)) as any;
+
+    await subFormFieldLinkageRules.handler(
+      {
+        model: {
+          hidden: false,
+          subModels: {
+            grid: {
+              forks: [rowGridFork],
+            },
+          },
+        },
+        flowKey: 'eventSettings',
+      } as any,
+      {
+        value: [
+          {
+            key: 'rule-1',
+            enable: true,
+            condition: { logic: '$and', items: [] },
+            actions: [
+              {
+                name: 'subFormLinkageSetFieldProps',
+                params: {
+                  value: {
+                    fields: ['field-a'],
+                    state: 'hidden',
+                  },
+                },
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(form.getFieldValue).toHaveBeenCalledWith(['items', 0, 'a']);
+    expect(targetFieldFork.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['items', 0, 'a'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
 });
 
 describe('linkageSetFieldProps action', () => {
@@ -541,6 +651,263 @@ describe('linkageSetFieldProps action', () => {
     expect(form.setFieldValue).not.toHaveBeenCalled();
   });
 
+  it('should clear form value when a field is hidden without reserving value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn(() => '123'),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      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: ['name-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['name'], 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 }>) => {
+      for (const patch of patches) {
+        if (patch.path.length === 1 && patch.path[0] === 'name') {
+          formValues.name = patch.value;
+        }
+      }
+    });
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (path.length === 1 && path[0] === 'name') {
+          return formValues.name;
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      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) => {
+        if (name === 'linkageSetFieldProps') return linkageSetFieldProps;
+        if (name === 'linkageAssignField') return linkageAssignField;
+        return 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: ['name-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+            {
+              key: 'action-2',
+              name: 'linkageAssignField',
+              params: {
+                value: [
+                  {
+                    key: 'assign-1',
+                    enable: true,
+                    targetPath: 'name',
+                    value: 'assigned',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(formValues.name).toBeUndefined();
+    expect(setFormValues).not.toHaveBeenCalled();
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
+  it('should not clear form value when a field is hidden with reserved value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn(() => '123'),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      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: ['name-field'],
+                  state: 'hiddenReservedValue',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(false);
+    expect(fieldModel.props.hidden).toBe(true);
+    expect(setFormValues).not.toHaveBeenCalled();
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
   it('should keep all options selectable after options were limited once', async () => {
     const fieldComponentModel: any = {
       uid: 'status-field-component',

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

@@ -46,7 +46,7 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it('runs linkage action on master model when forks are not mounted in runtime mode', async () => {
+  it('skips master model when forks can handle flow even if regular action buttons do not attach refs', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
@@ -74,6 +74,28 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('runs linkage action on master model when no forks exist in runtime mode', async () => {
+    const handler = vi.fn(async () => {});
+    const model: any = {
+      isFork: false,
+      forks: new Set(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn(() => ({ value: ['master-runtime'] })),
+    };
+    const ctx: any = {
+      model,
+      resolveJsonTemplate: vi.fn(async (p: any) => p),
+      getAction: vi.fn(() => ({ handler })),
+    };
+
+    await linkageRulesRefresh.handler(ctx, {
+      actionName: 'actionLinkageRules',
+      flowKey: 'buttonSettings',
+    });
+
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-runtime'] });
   });
 

package/src/flow/actions/dataScope.tsx

@@ -33,7 +33,14 @@ export const dataScope = defineAction({
         return (
           <FilterGroup
             value={props.value}
-            FilterItem={(p) => <VariableFilterItem {...p} model={flowContext.model} rightAsVariable />}
+            FilterItem={(p) => (
+              <VariableFilterItem
+                {...p}
+                model={flowContext.model}
+                rightAsVariable
+                maxAssociationFieldDepth={flowContext.model instanceof FieldModel ? undefined : 2}
+              />
+            )}
           />
         );
       },