@nocobase/client-v2 2.2.0-alpha.6 → 2.2.0-alpha.8

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -62,6 +62,51 @@ async function buildCollectionLeftMetaTreeLocal(ctx: any): Promise<MetaTreeNode[
   return await resolve(subTree);
 }
 
+function buildCollectionFieldMetaNode(collection: any, path: string[]): MetaTreeNode | null {
+  if (!collection || !path.length) {
+    return null;
+  }
+
+  const normalizedPath = path[0] === 'collection' ? path.slice(1) : path;
+  if (!normalizedPath.length) {
+    return null;
+  }
+
+  const parentTitles: string[] = [];
+  let currentCollection = collection;
+  let currentNode: MetaTreeNode | null = null;
+
+  for (const segment of normalizedPath) {
+    const field =
+      currentCollection?.getField?.(segment) ??
+      currentCollection?.getFields?.()?.find?.((candidate: any) => candidate?.name === segment);
+    if (!field) {
+      return null;
+    }
+
+    const title = field.title || field.uiSchema?.title || field.name || segment;
+    currentNode = {
+      name: field.name || segment,
+      title,
+      type: field.type,
+      interface: field.interface,
+      uiSchema: field.uiSchema,
+      options: field.options,
+      paths: ['collection', ...normalizedPath.slice(0, parentTitles.length + 1)],
+      parentTitles: [...parentTitles],
+    } as MetaTreeNode;
+
+    if (field.targetCollection) {
+      parentTitles.push(title);
+      currentCollection = field.targetCollection;
+    } else {
+      currentCollection = null;
+    }
+  }
+
+  return currentNode;
+}
+
 export interface VariableFilterItemValue {
   path: string;
   operator: string;
@@ -75,6 +120,7 @@ export interface VariableFilterItemProps {
   /** 筛选条件值对象 */
   value: VariableFilterItemValue;
   model: FlowModel;
+  disabled?: boolean;
   /**
    * 是否启用右侧 VariableInput（变量或静态值二合一）。
    * 默认 false：保持原有行为，右侧仅静态输入组件。
@@ -265,11 +311,48 @@ function normalizeRightValueInput(input: unknown) {
   return input;
 }
 
+function findMetaTreeNodeByPath(metaTree: MetaTreeNode[], targetPath: string[]): MetaTreeNode | null {
+  if (!Array.isArray(metaTree) || !targetPath.length) {
+    return null;
+  }
+
+  const traverseByName = (nodes: MetaTreeNode[], path: string[]): MetaTreeNode | null => {
+    if (!path.length) {
+      return null;
+    }
+
+    const [head, ...rest] = path;
+    const matched = nodes.find((node) => String(node.name) === String(head));
+    if (!matched) {
+      return null;
+    }
+    if (!rest.length) {
+      return matched;
+    }
+    if (!Array.isArray(matched.children)) {
+      return null;
+    }
+    return traverseByName(matched.children as MetaTreeNode[], rest);
+  };
+
+  const byNames = traverseByName(metaTree, targetPath);
+  if (byNames) {
+    return byNames;
+  }
+
+  const topNames = new Set(metaTree.map((node) => String(node.name)));
+  if (!topNames.has(String(targetPath[0]))) {
+    return traverseByName(metaTree, targetPath.slice(1));
+  }
+
+  return null;
+}
+
 /**
  * 上下文筛选项组件
  */
 export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
-  ({ value, model, rightAsVariable, rightMetaTree, ignoreFieldNames, maxAssociationFieldDepth }) => {
+  ({ value, model, disabled = false, rightAsVariable, rightMetaTree, ignoreFieldNames, maxAssociationFieldDepth }) => {
     // 使用 View 上下文，确保可访问 ctx.view 的异步子树
     const ctx = useFlowViewContext();
     const t = model.translate;
@@ -334,6 +417,9 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
     // 处理左侧值变化（值由 converters 决定如何解析）
     const handleLeftChange = useCallback(
       (variableValue: string, meta?: MetaTreeNode) => {
+        if (disabled) {
+          return;
+        }
         const prevPath = value.path || '';
         const nextPath = variableValue || '';
         const changed = nextPath !== prevPath;
@@ -348,7 +434,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
           setLeftMeta(meta);
         }
       },
-      [value],
+      [disabled, value],
     );
 
     // 自定义转换器来捕获 MetaTreeNode，并在选择左值时设置默认操作符
@@ -376,6 +462,9 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
     // 处理操作符变化
     const handleOperatorChange = useCallback(
       (operatorValue: string) => {
+        if (disabled) {
+          return;
+        }
         value.operator = operatorValue;
         const cur = operatorMetaList.find((op) => op.value === operatorValue);
         if (cur?.noValue) {
@@ -386,7 +475,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
           value.noValue = false;
         }
       },
-      [operatorMetaList, value],
+      [disabled, operatorMetaList, value],
     );
 
     // 使用公共静态输入渲染器（抽取到 utils）
@@ -464,9 +553,12 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
 
     const setRightValue = useCallback(
       (next: unknown) => {
+        if (disabled) {
+          return;
+        }
         value.value = normalizeRightValueInput(next) as VariableFilterItemValue['value'];
       },
-      [value],
+      [disabled, value],
     );
 
     // 右侧静态输入（无变量模式）与右侧 VariableInput 的静态渲染组件，统一复用
@@ -520,6 +612,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
               {...nextProps}
               style={{ width: '100%', ...pickStyle(nextProps.style) }}
               value={normalized}
+              disabled={disabled}
               onChange={(vals: any) => setRightValue(vals)}
             />
           </div>
@@ -529,10 +622,19 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
       const Comp = staticInputRenderer;
       return (
         <div style={{ flex: '1 1 40%', minWidth: 160, maxWidth: '100%' }}>
-          <Comp value={rightValue} onChange={(val) => setRightValue(val)} />
+          <Comp value={rightValue} onChange={(val) => setRightValue(val)} disabled={disabled} />
         </div>
       );
-    }, [operator, operatorMetaList, rightValue, staticInputRenderer, model.context.app, setRightValue, enumOptions]);
+    }, [
+      disabled,
+      operator,
+      operatorMetaList,
+      rightValue,
+      staticInputRenderer,
+      model.context.app,
+      setRightValue,
+      enumOptions,
+    ]);
 
     // Null 占位组件（仿照 DefaultValue.tsx 的实现）
     const NullComponent = useMemo(() => {
@@ -652,6 +754,34 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
       };
     }, [getFieldInterface, model, maxAssociationFieldDepth]);
 
+    useEffect(() => {
+      if (leftMeta || !value.path) {
+        return;
+      }
+
+      let cancelled = false;
+      const restore = async () => {
+        const nodes = await enhancedMetaTree();
+        if (cancelled) {
+          return;
+        }
+        const path = customConverters.resolvePathFromValue(value.path);
+        if (!path?.length) {
+          return;
+        }
+        const matched =
+          findMetaTreeNodeByPath(nodes, path) || buildCollectionFieldMetaNode(model.context.collection, path);
+        if (matched) {
+          setLeftMeta(matched);
+        }
+      };
+
+      restore();
+      return () => {
+        cancelled = true;
+      };
+    }, [customConverters, enhancedMetaTree, leftMeta, model.context.collection, value.path]);
+
     return (
       <Space wrap style={{ width: '100%' }}>
         <VariableInput
@@ -659,6 +789,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
           metaTree={enhancedMetaTree}
           onChange={handleLeftChange}
           converters={customConverters}
+          disabled={disabled}
           showValueComponent={false}
           style={{ flex: '1 1 40%', minWidth: 160, maxWidth: '100%' }}
           onlyLeafSelectable={true}
@@ -670,6 +801,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
           style={{ flex: '0 0 140px', minWidth: 120, maxWidth: '100%' }}
           placeholder={t('Comparison')}
           value={operator || undefined}
+          disabled={disabled}
           onChange={handleOperatorChange}
         >
           {operatorOptions.map((op) => (
@@ -686,6 +818,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
               onChange={(v) => setRightValue(v)}
               metaTree={mergedRightMetaTree}
               converters={rightConverters}
+              disabled={disabled}
               showValueComponent
               style={{ flex: '1 1 40%', minWidth: 160, maxWidth: '100%' }}
               placeholder={t('Enter value')}

package/src/flow/components/filter/__tests__/FilterGroup.test.tsx

@@ -140,4 +140,49 @@ describe('FilterGroup closeIcon', () => {
     expect(onChange).toHaveBeenCalledTimes(1);
     expect(value.items[0].items).toHaveLength(1);
   });
+
+  it('disables close and add actions when the filter group is disabled', () => {
+    const value = {
+      logic: '$and',
+      items: [
+        {
+          path: 'name',
+          operator: 'eq',
+          value: 'test',
+        },
+      ],
+    };
+    const onRemove = vi.fn();
+    const onChange = vi.fn();
+
+    renderWithProviders(
+      <FilterGroup
+        value={value}
+        FilterItem={DummyFilterItem}
+        showBorder
+        onRemove={onRemove}
+        onChange={onChange}
+        disabled
+      />,
+    );
+
+    const closeButtons = screen
+      .getAllByLabelText('icon-close')
+      .map((element) => element.closest('button'))
+      .filter(Boolean) as HTMLButtonElement[];
+    expect(closeButtons).toHaveLength(2);
+    expect(closeButtons[0]).toBeDisabled();
+    expect(closeButtons[1]).toBeDisabled();
+    expect(screen.getByText('Add condition').closest('button')).toBeDisabled();
+    expect(screen.getByText('Add condition group').closest('button')).toBeDisabled();
+
+    fireEvent.click(closeButtons[0]);
+    fireEvent.click(closeButtons[1]);
+    fireEvent.click(screen.getByText('Add condition').closest('button') as HTMLButtonElement);
+    fireEvent.click(screen.getByText('Add condition group').closest('button') as HTMLButtonElement);
+
+    expect(onRemove).not.toHaveBeenCalled();
+    expect(onChange).not.toHaveBeenCalled();
+    expect(value.items).toHaveLength(1);
+  });
 });

package/src/flow/components/filter/__tests__/VariableFilterItem.leftMetaTree.test.tsx

@@ -193,4 +193,13 @@ describe('VariableFilterItem with leftMetaTree', () => {
     fireEvent.click(screen.getByTestId('variable-input'));
     expect(value.path).toBe('title');
   });
+
+  it('restores the saved left meta so the operator select shows its label on reopen', async () => {
+    const value = { path: 'title', operator: '$eq', value: 'x' } as any;
+    const model = createModelWithCollection();
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+
+    expect(await screen.findByText('Equals')).toBeInTheDocument();
+  });
 });

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -158,6 +158,27 @@ describe('VariableFilterItem', () => {
     expect(value.value).toBe('abc');
   });
 
+  it('passes disabled through to the left selector, operator select, and right variable input', async () => {
+    const value: VariableFilterItemValue = { path: '', operator: '', value: '' };
+    const model = CreateModel();
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable disabled />);
+
+    const leftVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    expect(leftVariableInputProps.disabled).toBe(true);
+
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+
+    const variableInputs = screen.getAllByTestId('variable-input');
+    expect(variableInputs.length).toBeGreaterThanOrEqual(2);
+    const rightVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    expect(rightVariableInputProps.disabled).toBe(true);
+
+    const operatorSelect = document.body.querySelector('.ant-select') as HTMLDivElement | null;
+    expect(operatorSelect).not.toBeNull();
+    expect(operatorSelect).toHaveClass('ant-select-disabled');
+  });
+
   it('uses scoped context dataSourceManager when app dataSourceManager has no field interface manager', async () => {
     const value = observable({ path: '', operator: '', value: '' }) as any;
     const model = CreateModel();

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -431,6 +431,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
 
   private canApplyFormDefaultValue(name: string, current: any, force?: boolean) {
     if (force) return true;
+    if (this.userEditedFieldNames.has(name)) return false;
     if (isEmptyValue(current)) return true;
     if (!this.lastDefaultValueByFieldName.has(name)) return false;
     return isEqual(current, this.lastDefaultValueByFieldName.get(name));

package/src/flow/models/blocks/filter-form/FilterFormItemModel.tsx

@@ -62,9 +62,25 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
+interface CollectionFieldWithAssociationMarker {
+  isAssociationField?: () => boolean;
+  target?: unknown;
+}
+
+function hasAssociationMarker(value: unknown): value is CollectionFieldWithAssociationMarker {
+  return isRecord(value) && (typeof value.isAssociationField === 'function' || 'target' in value);
+}
+
+const isAssociationCollectionField = (collectionField: unknown) => {
+  if (!hasAssociationMarker(collectionField)) {
+    return false;
+  }
+  return collectionField.isAssociationField ? collectionField.isAssociationField() : Boolean(collectionField.target);
+};
+
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;
-  if (!collectionField?.isAssociationField?.()) {
+  if (!isAssociationCollectionField(collectionField)) {
     return value;
   }
 
@@ -171,8 +187,7 @@ const buildFilterFormFieldItem = ({
   if (!binding) {
     return;
   }
-  const isAssociation =
-    typeof field?.isAssociationField === 'function' ? field.isAssociationField() : Boolean(field?.target);
+  const isAssociation = isAssociationCollectionField(field);
   const fieldModel =
     isAssociation && ctxWithFlags.engine?.getModelClass?.('FilterFormRecordSelectFieldModel')
       ? 'FilterFormRecordSelectFieldModel'
@@ -507,10 +522,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
     const formValue = this.context.form?.getFieldValue(this.props.name);
     const modelValue = fieldModel.getFilterValue ? fieldModel.getFilterValue() : formValue;
     const collectionField = (fieldModel as any)?.context?.collectionField;
-    const isAssociationField =
-      typeof collectionField?.isAssociationField === 'function'
-        ? collectionField.isAssociationField()
-        : !!collectionField?.target;
+    const isAssociationField = isAssociationCollectionField(collectionField);
     const shouldUseFormValue =
       isAssociationField &&
       !this.mounted &&
@@ -547,11 +559,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
       return value;
     }
     const collectionField = (fieldModel as any)?.context?.collectionField;
-    const isAssociation =
-      typeof collectionField?.isAssociationField === 'function'
-        ? collectionField.isAssociationField()
-        : !!collectionField?.target;
-    if (!isAssociation) {
+    if (!isAssociationCollectionField(collectionField)) {
       return value;
     }
     const normalizedFieldNames = normalizeAssociationFieldNames(
@@ -798,6 +806,13 @@ FilterFormItemModel.registerFlow({
     },
     defaultOperator: {
       use: 'defaultOperator',
+      hideInSettings(ctx) {
+        const collectionField =
+          ctx.collectionField ||
+          ctx.model?.context?.collectionField ||
+          ctx.model?.subModels?.field?.context?.collectionField;
+        return isAssociationCollectionField(collectionField);
+      },
     },
     operatorComponentProps: {
       use: 'operatorComponentProps',

package/src/flow/models/blocks/filter-form/__tests__/FilterFormItemModel.defineChildren.test.ts

@@ -33,6 +33,42 @@ class DummyCollectionBlockModel extends CollectionBlockModel {
 }
 
 describe('FilterFormItemModel defineChildren association fields', () => {
+  it('hides default operator setting for association filter fields', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FilterFormItemModel,
+    });
+
+    const filterItem = engine.createModel<FilterFormItemModel>({
+      uid: 'association-filter-item-settings',
+      use: 'FilterFormItemModel',
+    });
+
+    const defaultOperatorStep = filterItem.getFlow('filterFormItemSettings')?.steps?.defaultOperator as {
+      hideInSettings?: (ctx: {
+        collectionField?: unknown;
+        model?: {
+          subModels?: {
+            field?: {
+              context?: {
+                collectionField?: unknown;
+              };
+            };
+          };
+        };
+      }) => boolean;
+    };
+    expect(defaultOperatorStep?.hideInSettings?.({ collectionField: { isAssociationField: () => true } })).toBe(true);
+    expect(
+      defaultOperatorStep?.hideInSettings?.({
+        model: { subModels: { field: { context: { collectionField: { target: 'departments' } } } } },
+      }),
+    ).toBe(true);
+    expect(defaultOperatorStep?.hideInSettings?.({ collectionField: { interface: 'input', type: 'string' } })).toBe(
+      false,
+    );
+  });
+
   it('groups association target fields and supports recursive paths', async () => {
     const engine = new FlowEngine();
     engine.registerModels({

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -301,6 +301,40 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Manual');
   });
 
+  it('does not reapply a filter form default value after user clears the field', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel([
+      {
+        key: 'username-default',
+        enable: true,
+        targetPath: 'username',
+        mode: 'default',
+        value: 'admin',
+      },
+    ]);
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('admin');
+
+    values.username_user = undefined;
+    (model as any).handleFilterFormValuesChange({ username_user: undefined }, { username_user: undefined });
+
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'formValuesChange',
+        {
+          changedValues: {
+            username_user: undefined,
+          },
+          allValues: {
+            username_user: undefined,
+          },
+        },
+        { debounce: true },
+      );
+    });
+    expect(values.username_user).toBeUndefined();
+  });
+
   it('applies fixed values even when the target filter field already has a value', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [