@nocobase/client-v2 2.1.0-beta.44 → 2.1.0-beta.45

package/src/flow/models/blocks/filter-manager/flow-actions/__tests__/customizeFilterRender.test.tsx

@@ -0,0 +1,148 @@
+/**
+ * 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 React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { FilterFormItemModel } from '../../../filter-form/FilterFormItemModel';
+import { customizeFilterRender } from '../customizeFilterRender';
+
+type TestFieldModel = {
+  props: Record<string, unknown>;
+  render: () => React.ReactNode;
+  setupReactiveRender: ReturnType<typeof vi.fn>;
+  _reactiveWrapperCache?: unknown;
+  __originalRender?: () => React.ReactNode;
+};
+
+const MultipleKeywordsInput = (props: Record<string, unknown>) => {
+  return <div data-testid="multiple-keywords-input" {...props} />;
+};
+
+function createFieldModel() {
+  return {
+    props: {
+      value: ['1', '2'],
+      placeholder: 'runtime placeholder',
+      onCompositionStart: vi.fn(),
+      onCompositionEnd: vi.fn(),
+    },
+    render: () => <span data-testid="original-field" />,
+    setupReactiveRender: vi.fn(),
+  };
+}
+
+function createFilterItemModel({
+  fieldModel,
+  operator = '$in',
+  collectionField,
+}: {
+  fieldModel: TestFieldModel;
+  operator?: string;
+  collectionField: Record<string, unknown>;
+}) {
+  return {
+    uid: 'filter-item',
+    operator,
+    collectionField,
+    context: {
+      app: {
+        getComponent: (name: string) => (name === 'MultipleKeywordsInput' ? MultipleKeywordsInput : undefined),
+      },
+      collectionField,
+    },
+    subModels: {
+      field: fieldModel,
+    },
+    setProps: vi.fn(),
+  } as unknown as FilterFormItemModel;
+}
+
+describe('customizeFilterRender action', () => {
+  it('uses operator schema components for number filter fields', () => {
+    const fieldModel = createFieldModel();
+    const model = createFilterItemModel({
+      fieldModel,
+      collectionField: {
+        interface: 'number',
+        type: 'integer',
+        filterable: {
+          operators: [
+            { label: 'equals', value: '$eq' },
+            {
+              label: 'is any of',
+              value: '$in',
+              schema: {
+                'x-component': 'MultipleKeywordsInput',
+                'x-component-props': {
+                  fieldInterface: 'number',
+                  placeholder: 'schema placeholder',
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    customizeFilterRender.handler?.({ model } as any);
+
+    const element = fieldModel.render();
+    expect(React.isValidElement(element)).toBe(true);
+    expect((element as React.ReactElement).type).toBe(MultipleKeywordsInput);
+    expect((element as React.ReactElement).props.fieldInterface).toBe('number');
+    expect((element as React.ReactElement).props.placeholder).toBe('runtime placeholder');
+    expect((element as React.ReactElement).props.onCompositionStart).toBeNull();
+    expect((element as React.ReactElement).props.onCompositionEnd).toBeNull();
+    expect(fieldModel.setupReactiveRender).toHaveBeenCalled();
+    expect(model.setProps).toHaveBeenCalledWith({ key: 'filter-item-$in' });
+
+    fieldModel.props = {
+      ...fieldModel.props,
+      value: ['3'],
+      placeholder: 'updated runtime placeholder',
+    };
+    const rerenderedElement = fieldModel.render();
+    expect((rerenderedElement as React.ReactElement).props.value).toEqual(['3']);
+    expect((rerenderedElement as React.ReactElement).props.placeholder).toBe('updated runtime placeholder');
+  });
+
+  it('restores original render when switching to an operator without a schema component', () => {
+    const fieldModel = createFieldModel();
+    const originalRender = fieldModel.render;
+    const model = createFilterItemModel({
+      fieldModel,
+      collectionField: {
+        interface: 'number',
+        type: 'integer',
+        filterable: {
+          operators: [
+            { label: 'equals', value: '$eq' },
+            {
+              label: 'is any of',
+              value: '$in',
+              schema: {
+                'x-component': 'MultipleKeywordsInput',
+                'x-component-props': {
+                  fieldInterface: 'number',
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    customizeFilterRender.handler?.({ model } as any);
+    model.operator = '$eq';
+    customizeFilterRender.handler?.({ model } as any);
+
+    expect(fieldModel.render).toBe(originalRender);
+    expect(fieldModel.render()).toEqual(<span data-testid="original-field" />);
+  });
+});

package/src/flow/models/blocks/filter-manager/flow-actions/__tests__/defaultOperator.test.tsx

@@ -9,6 +9,8 @@
 
 import { describe, it, expect, beforeEach } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { createMockClient, IdFieldInterface, InputFieldInterface } from '@nocobase/client-v2';
+import React from 'react';
 import { defaultOperator } from '../defaultOperator';
 
 function createModel() {
@@ -17,6 +19,12 @@ function createModel() {
   return model;
 }
 
+type OperatorOption = {
+  value: string;
+  label?: unknown;
+  schema?: Record<string, unknown>;
+};
+
 describe('defaultOperator action', () => {
   beforeEach(() => {
     document.body.innerHTML = '';
@@ -55,4 +63,81 @@ describe('defaultOperator action', () => {
     expect(options2.find((o: any) => o.value === '$a')).toBeTruthy();
     expect(options2.find((o: any) => o.value === '$b')).toBeTruthy();
   });
+
+  it('resolves default operator options from field interfaces when collection field metadata is absent', () => {
+    const app = createMockClient();
+    app.addFieldInterfaces([InputFieldInterface]);
+    app.addFieldInterfaceOperator('input', {
+      label: 'plugin in',
+      value: '$in',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+    app.addFieldInterfaceOperator('input', {
+      label: 'plugin not in',
+      value: '$notIn',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+
+    const model = new FlowModel({ uid: 'm-default-operator-interface', flowEngine: app.flowEngine });
+    model.context.defineProperty('filterField', {
+      value: { name: 'name', title: 'Name', interface: 'input', type: 'string' },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$in')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+    expect(options.find((item) => item.value === '$notIn')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+  });
+
+  it('preserves React operator labels', () => {
+    const model = createModel();
+    const label = <span data-testid="operator-label">plugin label</span>;
+
+    model.context.defineProperty('collectionField', {
+      value: {
+        filterable: {
+          operators: [{ value: '$in', label, schema: { 'x-component': 'MultipleKeywordsInput' } }],
+        },
+      },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$in')?.label).toBe(label);
+  });
+
+  it('falls back to id field interface operators when collection field operators are empty', () => {
+    const app = createMockClient();
+    app.addFieldInterfaces([IdFieldInterface]);
+    app.addFieldInterfaceOperator('id', {
+      label: 'plugin in',
+      value: '$in',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+    app.addFieldInterfaceOperator('id', {
+      label: 'plugin not in',
+      value: '$notIn',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+
+    const model = new FlowModel({ uid: 'm-default-operator-id-interface', flowEngine: app.flowEngine });
+    model.context.defineProperty('collectionField', {
+      value: {
+        name: 'id',
+        title: 'ID',
+        interface: 'id',
+        type: 'bigInt',
+        filterable: { operators: [] },
+      },
+    });
+    model.context.defineProperty('filterField', {
+      value: { name: 'id', title: 'ID', interface: 'id', type: 'bigInt' },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$eq')).toBeTruthy();
+    expect(options.find((item) => item.value === '$in')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+    expect(options.find((item) => item.value === '$notIn')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+  });
 });

package/src/flow/models/blocks/filter-manager/flow-actions/connectFields.tsx

@@ -40,7 +40,20 @@ export const connectFields = defineAction({
 });
 
 // 构建级联选项数据结构
-const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: string[] = [], labelPrefix = '') => {
+const MAX_ASSOCIATION_FIELD_DEPTH = 2;
+
+const isAssociationField = (field: any) => {
+  return Boolean(field?.target || field?.targetCollection);
+};
+
+const buildCascaderOptions = (
+  ctx,
+  fields: any[],
+  prefix = '',
+  selectedPaths: string[] = [],
+  labelPrefix = '',
+  associationDepth = 0,
+) => {
   const selectedPathsArray = selectedPaths.filter(Boolean);
 
   return fields
@@ -48,7 +61,13 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
       const currentPath = prefix ? `${prefix}.${field.name}` : field.name;
       const label = field.title || field.name;
       const fullLabel = labelPrefix ? `${labelPrefix} / ${label}` : label;
-      const isLeaf = !field.target;
+      const isAssociation = isAssociationField(field);
+      const nextAssociationDepth = associationDepth + (isAssociation ? 1 : 0);
+      if (isAssociation && nextAssociationDepth > MAX_ASSOCIATION_FIELD_DEPTH) {
+        return null;
+      }
+
+      const isLeaf = !isAssociation;
 
       const option: any = {
         label,
@@ -59,6 +78,7 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
           field,
           fullPath: currentPath,
           fullLabel,
+          associationDepth: nextAssociationDepth,
         },
       };
 
@@ -68,18 +88,33 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
 
       if (shouldLoadChildren) {
         if (field.filterable?.children?.length) {
-          option.children = buildCascaderOptions(ctx, field.filterable.children, currentPath, selectedPaths, fullLabel);
+          option.children = buildCascaderOptions(
+            ctx,
+            field.filterable.children,
+            currentPath,
+            selectedPaths,
+            fullLabel,
+            nextAssociationDepth,
+          );
         } else {
           const targetCollection = field.targetCollection;
           if (targetCollection) {
             const targetFields = targetCollection.getFields?.() || [];
-            option.children = buildCascaderOptions(ctx, targetFields, currentPath, selectedPaths, fullLabel);
+            option.children = buildCascaderOptions(
+              ctx,
+              targetFields,
+              currentPath,
+              selectedPaths,
+              fullLabel,
+              nextAssociationDepth,
+            );
           }
         }
       }
 
       return option;
     })
+    .filter(Boolean)
     .sort((a, b) => {
       // isLeaf 为 true 的节点排在前面
       if (a.isLeaf && !b.isLeaf) return -1;
@@ -259,7 +294,7 @@ function ConnectFields(
           <li>{ctx.t('Available "target blocks" are all data blocks on the current page')}</li>
           <li>
             {ctx.t(
-              'Support filtering multiple blocks simultaneously, support deep selection of relationship fields (e.g.: User/Department/Name)',
+              'Support filtering multiple blocks simultaneously, support selection of relationship fields up to two levels (e.g.: User/Department/Name)',
             )}
           </li>
         </ul>
@@ -469,7 +504,14 @@ function CascaderWrapper(
       return;
     }
 
-    target.children = buildCascaderOptions(ctx, childFields, fullPath, [], meta.fullLabel || target.label);
+    target.children = buildCascaderOptions(
+      ctx,
+      childFields,
+      fullPath,
+      [],
+      meta.fullLabel || target.label,
+      meta.associationDepth || 0,
+    );
     setOptions((prev) => [...prev]);
   };
 

package/src/flow/models/blocks/filter-manager/flow-actions/customizeFilterRender.tsx

@@ -7,25 +7,13 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import React from 'react';
 import { defineAction } from '@nocobase/flow-engine';
 import { FilterFormItemModel } from '../../filter-form/FilterFormItemModel';
-import { InputFieldModel } from '../../../fields/InputFieldModel';
-import { resolveOperatorComponent } from '../../../../internal/utils/operatorSchemaHelper';
-
-const KEYWORD_OPERATORS = new Set(['$in', '$notIn']);
-
-function isOperatorSupported(model: FilterFormItemModel, operator: string) {
-  const ops = model.collectionField?.filterable?.operators || [];
-  return ops.some((op) => op.value === operator);
-}
-
-// 重新包裹 render，确保仍由 flow-engine 的响应式包装驱动
-function rewrapReactiveRender(fieldModel: any) {
-  if (!fieldModel) return;
-  fieldModel._reactiveWrapperCache = undefined;
-  fieldModel.setupReactiveRender?.();
-}
+import {
+  applyOperatorComponentRender,
+  restoreOperatorComponentRender,
+} from '../../../../internal/utils/operatorSchemaHelper';
+import { getFilterFormOperatorList } from '../utils';
 
 function applyCustomizeFilterRender(model: FilterFormItemModel) {
   const operator = model.operator;
@@ -37,37 +25,19 @@ function applyCustomizeFilterRender(model: FilterFormItemModel) {
     key: `${model.uid}-${operator || ''}`,
   });
 
-  // 非关键词操作符，恢复原始渲染
-  if (!KEYWORD_OPERATORS.has(operator)) {
-    const originalRender = fieldModel['__originalRender'];
-    if (typeof originalRender === 'function') {
-      // 清理缓存，防止沿用上一轮的 reactive wrapper
-      (fieldModel as any)._reactiveWrapperCache = undefined;
-      fieldModel.render = originalRender;
-    }
+  if (!operator) {
+    restoreOperatorComponentRender(fieldModel);
     return;
   }
 
-  if (!(fieldModel instanceof InputFieldModel)) return;
-  if (!isOperatorSupported(model, operator)) return;
-
-  const resolved = resolveOperatorComponent(
-    model.context.app,
+  const operatorList = getFilterFormOperatorList(model);
+  applyOperatorComponentRender({
+    app: model.context.app,
+    fieldModel,
     operator,
-    model.collectionField?.filterable?.operators || [],
-  );
-  if (!resolved) return;
-  const { Comp, props: xProps } = resolved;
-
-  // 缓存一次原始 render/props，用于回退
-  if (!fieldModel['__originalRender']) {
-    fieldModel['__originalRender'] = fieldModel.render;
-  }
-
-  fieldModel.render = () => (
-    <Comp {...xProps} {...fieldModel.props} onCompositionStart={null} onCompositionEnd={null} />
-  );
-  rewrapReactiveRender(fieldModel);
+    operators: operatorList,
+    propsPriority: 'field',
+  });
 }
 
 export const customizeFilterRender = defineAction<FilterFormItemModel>({

package/src/flow/models/blocks/filter-manager/flow-actions/defaultOperator.tsx

@@ -8,8 +8,8 @@
  */
 
 import { defineAction, tExpr, FlowModel } from '@nocobase/flow-engine';
-import { operators } from '../../../../../flow-compat';
 import { FilterFormFieldModel } from '../../filter-form/fields';
+import { getFilterFormOperatorList } from '../utils';
 
 export const defaultOperator: any = defineAction<FilterFormFieldModel>({
   name: 'defaultOperator',
@@ -37,12 +37,10 @@ export const defaultOperator: any = defineAction<FilterFormFieldModel>({
 
 function getOperatorOptions(model: FlowModel) {
   const meta = model.context.collectionField || model.context.filterField;
-  const operatorList =
-    model.context.collectionField?.filterable?.operators || operators[model.context.filterField.type];
-  return (operatorList || [])
+  return getFilterFormOperatorList(model)
     .filter((op) => !op.visible || op.visible(meta))
     .map((op) => ({
       ...op,
-      label: model.translate(op.label),
+      label: typeof op.label === 'string' ? model.translate(op.label) : op.label,
     }));
 }

package/src/flow/models/blocks/filter-manager/flow-actions/operatorComponentProps.tsx

@@ -9,20 +9,10 @@
 
 import { defineAction } from '@nocobase/flow-engine';
 import { FilterFormItemModel } from '../../filter-form/FilterFormItemModel';
-
-function getOperatorMeta(model: FilterFormItemModel) {
-  const ops = model.collectionField?.filterable?.operators || [];
-  if (!ops.length) {
-    return null;
-  }
-  if (!model.operator) {
-    return null;
-  }
-  return ops.find((op) => op.value === model.operator) || null;
-}
+import { getFilterFormOperatorMeta } from '../utils';
 
 function applyOperatorComponentProps(model: FilterFormItemModel) {
-  const meta = getOperatorMeta(model);
+  const meta = getFilterFormOperatorMeta(model, model.operator);
   if (!meta) {
     return;
   }

package/src/flow/models/blocks/filter-manager/utils.ts

@@ -8,14 +8,153 @@
  */
 
 import { FlowModel } from '@nocobase/flow-engine';
+import {
+  normalizeFilterableOperators,
+  type FieldFilterable,
+  type FieldFilterOperator,
+} from '../../../../collection-manager/filter-operators';
+import { operators } from '../../../../flow-compat';
 import { BlockGridModel, CollectionBlockModel } from '../../base';
 
-export function getDefaultOperator(model: any) {
+type FilterFormFieldMeta = {
+  filterable?: FieldFilterable<unknown> | false;
+  interface?: string;
+  type?: string;
+};
+
+type FilterFormOperatorModel = FlowModel & {
+  operator?: string;
+  collectionField?: FilterFormFieldMeta;
+  filterField?: FilterFormFieldMeta;
+  subModels?: {
+    field?: {
+      operator?: string;
+    };
+  };
+  getStepParams?: (flowKey: string, stepKey: string) => { value?: string } | undefined;
+};
+
+function getModelContext(model: FlowModel) {
+  return model.context as unknown as Record<string, unknown>;
+}
+
+function getModelField(model: FlowModel, key: 'collectionField' | 'filterField') {
+  const modelWithFields = model as FilterFormOperatorModel;
+  const field = modelWithFields[key] || getModelContext(model)?.[key];
+  return field && typeof field === 'object' ? (field as FilterFormFieldMeta) : undefined;
+}
+
+function getDataSourceManager(model: FlowModel) {
+  const contextManager = getModelContext(model)?.dataSourceManager;
+  if (contextManager) {
+    return contextManager as Record<string, unknown>;
+  }
+  return model.flowEngine?.context?.dataSourceManager as unknown as Record<string, unknown> | undefined;
+}
+
+function cloneFilterable(filterable: FieldFilterable<unknown>): FieldFilterable<unknown> {
+  return {
+    operatorGroup: filterable.operatorGroup,
+    operators: Array.isArray(filterable.operators) ? [...filterable.operators] : filterable.operators,
+    operatorOverrides: Array.isArray(filterable.operatorOverrides)
+      ? [...filterable.operatorOverrides]
+      : filterable.operatorOverrides,
+  };
+}
+
+function getFilterableOperators(filterable?: FieldFilterable<unknown> | false) {
+  if (filterable === false) {
+    return [];
+  }
+
+  if (!filterable || typeof filterable !== 'object') {
+    return;
+  }
+
+  const normalized = normalizeFilterableOperators(cloneFilterable(filterable));
+  if (Array.isArray(normalized?.operators) && normalized.operators.length > 0) {
+    return normalized.operators;
+  }
+
+  if (Array.isArray(normalized?.operatorOverrides) && normalized.operatorOverrides.length > 0) {
+    return normalized.operatorOverrides;
+  }
+}
+
+function getFieldInterfaceFilterable(model: FlowModel, field?: FilterFormFieldMeta) {
+  const interfaceName = typeof field?.interface === 'string' ? field.interface : undefined;
+  if (!interfaceName) {
+    return;
+  }
+
+  const dataSourceManager = getDataSourceManager(model);
+  const fieldInterfaceManager = dataSourceManager?.collectionFieldInterfaceManager as
+    | {
+        getFieldInterface?: (name: string) => { filterable?: FieldFilterable<unknown> | false } | undefined;
+      }
+    | undefined;
+  const fieldInterface = fieldInterfaceManager?.getFieldInterface?.(interfaceName);
+  return fieldInterface?.filterable;
+}
+
+function getFallbackOperators(field?: FilterFormFieldMeta) {
+  const fallbackKeys = [field?.interface, field?.type].filter((item): item is string => typeof item === 'string');
+  const standardOperators = operators as Record<string, FieldFilterOperator<unknown>[] | undefined>;
+  for (const key of fallbackKeys) {
+    const operatorList = standardOperators[key];
+    if (operatorList?.length) {
+      return operatorList;
+    }
+  }
+  return [];
+}
+
+export function getFilterFormOperatorList(model: FlowModel) {
+  const collectionField = getModelField(model, 'collectionField');
+  const filterField = getModelField(model, 'filterField');
+  const field = collectionField || filterField;
+
+  if (field?.filterable === false) {
+    return [];
+  }
+
+  const fieldOperators = getFilterableOperators(field?.filterable);
+  if (fieldOperators?.length) {
+    return fieldOperators;
+  }
+
+  const fieldInterfaceFilterable = getFieldInterfaceFilterable(model, field);
+  if (fieldInterfaceFilterable === false) {
+    return [];
+  }
+
+  const fieldInterfaceOperators = getFilterableOperators(fieldInterfaceFilterable);
+  if (fieldInterfaceOperators?.length) {
+    return fieldInterfaceOperators;
+  }
+
+  return getFallbackOperators(field);
+}
+
+export function getFilterFormOperatorMeta(model: FlowModel, operator = getDefaultOperator(model)) {
+  if (!operator) {
+    return null;
+  }
+
+  const meta = getModelField(model, 'collectionField') || getModelField(model, 'filterField');
+  return (
+    getFilterFormOperatorList(model).find((op) => op.value === operator && (!op.visible || op.visible(meta))) || null
+  );
+}
+
+export function getDefaultOperator(model: FilterFormOperatorModel) {
+  const operatorList = getFilterFormOperatorList(model);
   return (
     model.operator ||
-    model.getStepParams('filterFormItemSettings', 'defaultOperator')?.value ||
-    model.subModels.field?.operator ||
-    model.collectionField?.filterable?.operators?.[0]?.value ||
+    model.getStepParams?.('filterFormItemSettings', 'defaultOperator')?.value ||
+    model.subModels?.field?.operator ||
+    operatorList.find((op) => op.selected)?.value ||
+    operatorList[0]?.value ||
     '$includes'
   );
 }

package/src/flow/models/blocks/form/FormAssociationItemModel.tsx

@@ -22,6 +22,8 @@ import { FieldModel } from '../../base/FieldModel';
 import { rebuildFieldSubModel } from '../../../internal/utils/rebuildFieldSubModel';
 import { useJsonTemplateResolver } from '../../../utils/useJsonTemplateResolver';
 
+const MAX_FORM_ASSOCIATION_FIELD_DEPTH = 2;
+
 function mergeArrays(a, b) {
   if (!b) {
     return a;
@@ -84,10 +86,17 @@ const AssociationItem = (props) => {
 export class FormAssociationItemModel extends DisplayItemModel {
   static defineChildren(ctx: FlowModelContext) {
     const collection = ctx.collection as Collection;
+    const associationDepth = ctx.prefixFieldPath ? ctx.prefixFieldPath.split('.').filter(Boolean).length : 0;
 
     return collection
       .getFields()
       .map((field) => {
+        if (
+          associationDepth >= MAX_FORM_ASSOCIATION_FIELD_DEPTH &&
+          (field.isAssociationField?.() || field.target || field.targetCollection)
+        ) {
+          return null;
+        }
         const binding = this.getDefaultBindingByField(ctx, field, { fallbackToTargetTitleField: true });
         if (!binding) return null;
         const fieldModel = binding.modelName;

package/src/flow/models/blocks/form/FormItemModel.tsx

@@ -42,12 +42,21 @@ const interfacesOfUnsupportedDefaultValue = [
   'formula',
 ];
 
+const MAX_FORM_ASSOCIATION_FIELD_DEPTH = 2;
+
 export class FormItemModel<T extends DefaultStructure = DefaultStructure> extends EditableItemModel<T> {
   static defineChildren(ctx: FlowModelContext) {
     const collection = ctx.collection as Collection;
+    const associationDepth = ctx.prefixFieldPath ? ctx.prefixFieldPath.split('.').filter(Boolean).length : 0;
     return collection
       .getFields()
       .map((field) => {
+        if (
+          associationDepth >= MAX_FORM_ASSOCIATION_FIELD_DEPTH &&
+          (field.isAssociationField?.() || field.target || field.targetCollection)
+        ) {
+          return;
+        }
         const binding = this.getDefaultBindingByField(ctx, field);
         if (!binding) {
           return;