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

package/src/flow/components/FieldAssignValueInput.tsx

@@ -36,10 +36,11 @@ import {
   isToManyAssociationField,
 } from '../internal/utils/modelUtils';
 import { RunJSValueEditor } from './RunJSValueEditor';
-import { resolveOperatorComponent } from '../internal/utils/operatorSchemaHelper';
+import { pickOperatorStyle as pickStyle, resolveOperatorComponent } from '../internal/utils/operatorSchemaHelper';
 import { InputFieldModel } from '../models/fields/InputFieldModel';
 import { normalizeFilterValueByOperator } from '../models/blocks/filter-form/valueNormalization';
 import { FieldAssignExactDatePicker, type ExactDatePickerMode } from './FieldAssignExactDatePicker';
+import { limitAssociationMetaTree } from './filter/metaTreeAssociationDepth';
 
 const DATE_FIELD_INTERFACES = new Set(['date', 'datetime', 'datetimeNoTz', 'createdAt', 'updatedAt', 'unixTimestamp']);
 
@@ -340,6 +341,7 @@ interface Props {
    * 默认 false，保持历史行为。
    */
   enableDateVariableAsConstant?: boolean;
+  maxAssociationFieldDepth?: number;
 }
 
 type ResolvedFieldContext = {
@@ -352,14 +354,6 @@ type ResolvedFieldContext = {
   collectionField: CollectionField | null;
 };
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function pickStyle(value: unknown): React.CSSProperties | undefined {
-  return isPlainObject(value) ? (value as React.CSSProperties) : undefined;
-}
-
 function withFullWidthStyle(style?: React.CSSProperties): React.CSSProperties {
   return { ...style, width: '100%', minWidth: 0 };
 }
@@ -718,6 +712,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
   preferFormItemFieldModel,
   associationFieldNamesOverride,
   enableDateVariableAsConstant = false,
+  maxAssociationFieldDepth = 2,
 }) => {
   const flowCtx = useFlowContext<FlowModelContext>();
   const normalizeEventValue = React.useCallback((eventOrValue: unknown) => {
@@ -859,7 +854,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       fieldName,
       collectionField: nested.collectionField || null,
     };
-  }, [flowCtx.model, itemModel, resolveNestedAssociationField, targetPath]);
+  }, [flowCtx, itemModel, resolveNestedAssociationField, targetPath]);
 
   const { collection, dataSource, blockModel, fieldPath, fieldName, collectionField: cf } = resolved;
   const itemCollectionField = (resolved?.itemModel as any)?.context?.collectionField;
@@ -1172,7 +1167,11 @@ export const FieldAssignValueInput: React.FC<Props> = ({
         <Comp
           {...fieldModel.props}
           {...xProps}
-          style={{ width: '100%', ...(fieldModel.props as any)?.style, ...xProps?.style }}
+          style={{
+            width: '100%',
+            ...pickStyle((fieldModel.props as Record<string, unknown>)?.style),
+            ...pickStyle(xProps?.style),
+          }}
         />
       );
       rewrapReactiveRender(fieldModel);
@@ -1232,7 +1231,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       );
     };
     return C;
-  }, [placeholder, tempRoot, coerceEmptyValueForRenderer, normalizeEventValue]);
+  }, [placeholder, tempRoot, coerceEmptyValueForRenderer, normalizeEventValue, operator]);
 
   const DateVariableConstantEditor = React.useMemo(() => {
     const C: React.FC<any> = (inputProps) => {
@@ -1408,6 +1407,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       const extra = extraMetaTreeRef.current;
       const extraTree = Array.isArray(extra) ? extra : [];
       const mergedBase = mergeItemMetaTreeForAssignValue(base as MetaTreeNode[], extraTree as MetaTreeNode[]);
+      const limitedBase = limitAssociationMetaTree(mergedBase, { maxAssociationDepth: maxAssociationFieldDepth });
       return [
         {
           title: tExpr('Constant'),
@@ -1418,10 +1418,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
         },
         { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
         { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-        ...mergedBase,
+        ...limitedBase,
       ];
     };
-  }, [flowCtx, ConstantEditor, NullComponent, RunJSComponent]);
+  }, [flowCtx, ConstantEditor, NullComponent, RunJSComponent, maxAssociationFieldDepth]);
 
   const displayValue = React.useMemo(() => {
     if (!useDateVariableConstant) {

package/src/flow/components/__tests__/FieldAssignRulesEditor.test.tsx

@@ -108,6 +108,54 @@ describe('FieldAssignRulesEditor', () => {
     };
   };
 
+  const createAssociationFixtureWithoutIsAssociationField = () => {
+    const profileCollection = {
+      titleField: 'name',
+      filterTargetKey: 'id',
+      getField: (name: string) => {
+        if (name === 'name') {
+          return { name: 'name', title: 'Name', interface: 'input' };
+        }
+        if (name === 'nickname') {
+          return { name: 'nickname', title: 'Nickname', interface: 'input' };
+        }
+        return null;
+      },
+      getFields: () => [
+        {
+          name: 'name',
+          title: 'Name',
+          interface: 'input',
+        },
+        {
+          name: 'nickname',
+          title: 'Nickname',
+          interface: 'input',
+        },
+      ],
+    };
+
+    const profileField: any = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetKey: 'id',
+      targetCollection: profileCollection,
+    };
+
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+
+    return {
+      profileCollection,
+      rootCollection,
+    };
+  };
+
   const openAdvancedPanel = async () => {
     await userEvent.click(screen.getByRole('button', { name: /Advanced/i }));
     await screen.findByText('Title field');
@@ -175,6 +223,68 @@ describe('FieldAssignRulesEditor', () => {
     });
   });
 
+  it('recognizes lightweight association fields without isAssociationField()', async () => {
+    const { rootCollection } = createAssociationFixtureWithoutIsAssociationField();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile',
+        enable: true,
+        targetPath: 'profile',
+        mode: 'assign',
+      },
+    ];
+
+    const { container } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+          isTitleFieldCandidate={() => true}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      const input = container.querySelector('[data-testid="mock-value-input"]');
+      expect(input?.getAttribute('data-assoc-label')).toBe('name');
+      expect(input?.getAttribute('data-assoc-value')).toBe('id');
+    });
+  });
+
+  it('resolves nested labels and item meta tree through lightweight association fields', async () => {
+    const { rootCollection } = createAssociationFixtureWithoutIsAssociationField();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    const { container } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+          isTitleFieldCandidate={() => true}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(container.textContent).toContain('Profile / Nickname');
+      const input = container.querySelector('[data-testid="mock-value-input"]');
+      expect(input?.getAttribute('data-extra')).toBe('yes');
+    });
+  });
+
   it('saves selected title field into current assign rule without syncing', async () => {
     const { rootCollection, value } = createAssociationFixture();
     const onChange = vi.fn();
@@ -785,7 +895,8 @@ describe('FieldAssignRulesEditor', () => {
     expect(merged.map((node) => node.name)).toEqual(['formValues', 'item', 'user']);
     expect(merged.filter((node) => node.name === 'item')).toHaveLength(1);
 
-    const itemNode = merged.find((node) => node.name === 'item')!;
+    const itemNode = merged.find((node) => node.name === 'item');
+    expect(itemNode).toBeTruthy();
     const parent = (itemNode.children as MetaTreeNode[]).find((node) => node.name === 'parentItem');
     expect(parent).toBeTruthy();
 

package/src/flow/components/__tests__/fieldAssignOptions.test.ts

@@ -9,7 +9,10 @@
 
 import { describe, expect, it } from 'vitest';
 import { buildCustomFieldTargetPath } from '../../internal/utils/modelUtils';
-import { collectFieldAssignCascaderOptions } from '../fieldAssignOptions';
+import {
+  buildFieldAssignCascaderOptionsFromCollection,
+  collectFieldAssignCascaderOptions,
+} from '../fieldAssignOptions';
 
 describe('fieldAssignOptions', () => {
   it('marks subform node as non-leaf so Cascader can lazy-load target collection fields', () => {
@@ -94,4 +97,71 @@ describe('fieldAssignOptions', () => {
       options.some((o: any) => o?.value === customTargetPath && o?.label === 'Custom age' && o?.isLeaf === true),
     ).toBe(true);
   });
+
+  it('hides configured association fields deeper than relation / relation / field', () => {
+    const makeItem = (fieldPath: string, field: any, label: string) => ({
+      props: { label },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: field },
+        },
+      },
+    });
+
+    const companyField = {
+      name: 'company',
+      title: 'Company',
+      interface: 'm2o',
+      target: 'companies',
+      isAssociationField: () => true,
+      targetCollection: { getFields: () => [] },
+    };
+    const nameField = {
+      name: 'name',
+      title: 'Name',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const formBlockModel = {
+      context: { collection: null },
+      subModels: {
+        grid: {
+          subModels: {
+            items: [
+              makeItem('users.department.name', nameField, 'Department name'),
+              makeItem('users.department.company', companyField, 'Company'),
+            ],
+          },
+        },
+      },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+
+    expect(options.map((item) => item.value)).toContain('name');
+    expect(options.map((item) => item.value)).not.toContain('company');
+  });
+
+  it('hides lazy-loaded association selector options after two association levels', () => {
+    const collection = {
+      getFields: () => [
+        { name: 'name', title: 'Name', interface: 'input' },
+        {
+          name: 'company',
+          title: 'Company',
+          interface: 'm2o',
+          target: 'companies',
+          targetCollection: { getFields: () => [] },
+        },
+      ],
+    };
+
+    const options = buildFieldAssignCascaderOptionsFromCollection(collection, (s) => s, { associationDepth: 2 });
+
+    expect(options.map((item) => item.value)).toEqual(['name']);
+  });
 });

package/src/flow/components/fieldAssignOptions.ts

@@ -76,10 +76,15 @@ function getCollectionFromFormBlockModel(model: any): CollectionLike | null {
   return collection && typeof collection === 'object' ? (collection as CollectionLike) : null;
 }
 
-function buildRootOptionsFromCollection(
+export function buildFieldAssignCascaderOptionsFromCollection(
   collection: CollectionLike | null,
   t: (key: string) => string,
+  options: {
+    associationDepth?: number;
+    maxAssociationFieldDepth?: number;
+  } = {},
 ): FieldAssignCascaderOption[] {
+  const { associationDepth = 0, maxAssociationFieldDepth = 2 } = options;
   const fields = typeof collection?.getFields === 'function' ? collection.getFields() || [] : [];
   const out: FieldAssignCascaderOption[] = [];
   for (const rawField of fields) {
@@ -88,6 +93,7 @@ function buildRootOptionsFromCollection(
       name?: unknown;
       title?: unknown;
       interface?: unknown;
+      target?: unknown;
       isAssociationField?: () => boolean;
       targetCollection?: any;
     };
@@ -99,8 +105,11 @@ function buildRootOptionsFromCollection(
     if (!name) continue;
     const title = t(typeof f.title === 'string' ? f.title : name);
 
-    const isAssoc = !!f.isAssociationField?.();
+    const isAssoc = !!(f.isAssociationField?.() || f.target || f.targetCollection);
     const hasTarget = !!f.targetCollection;
+    if (isAssoc && associationDepth >= maxAssociationFieldDepth) {
+      continue;
+    }
 
     out.push({
       label: title,
@@ -138,8 +147,9 @@ export function collectFieldAssignCascaderOptions(options: {
   t: (key: string) => string;
   /** 子表单模型递归深度（FormItemModel 层级）；默认不限制（只受实际配置与循环引用约束） */
   maxFormItemDepth?: number;
+  maxAssociationFieldDepth?: number;
 }): FieldAssignCascaderOption[] {
-  const { formBlockModel, t, maxFormItemDepth = Number.POSITIVE_INFINITY } = options;
+  const { formBlockModel, t, maxFormItemDepth = Number.POSITIVE_INFINITY, maxAssociationFieldDepth = 2 } = options;
 
   const rootItems = formBlockModel?.subModels?.grid?.subModels?.items || [];
   const rootCollection = getCollectionFromFormBlockModel(formBlockModel);
@@ -167,9 +177,14 @@ export function collectFieldAssignCascaderOptions(options: {
 
       const fieldModel = item?.subModels?.field;
       const childItems = fieldModel?.subModels?.grid?.subModels?.items;
-      const cf: CollectionField | undefined = fieldModel?.context?.collectionField;
-      const isAssociation = !!cf?.isAssociationField?.();
+      const cf: (CollectionField & { target?: unknown; targetCollection?: unknown }) | undefined =
+        fieldModel?.context?.collectionField;
+      const isAssociation = !!(cf?.isAssociationField?.() || cf?.target || cf?.targetCollection);
       const hasTargetCollection = !!cf?.targetCollection;
+      const associationDepth = isAssociation ? targetPath.split('.').filter(Boolean).length : 0;
+      if (isAssociation && associationDepth > maxAssociationFieldDepth) {
+        continue;
+      }
 
       // 1) 子表单/子表单列表：递归展开已配置字段（支持无限深度）。
       //
@@ -207,6 +222,8 @@ export function collectFieldAssignCascaderOptions(options: {
   };
 
   const configuredOptions = walkItems(rootItems, 1);
-  const allFieldOptions = buildRootOptionsFromCollection(rootCollection, t);
+  const allFieldOptions = buildFieldAssignCascaderOptionsFromCollection(rootCollection, t, {
+    maxAssociationFieldDepth,
+  });
   return mergeRootOptions(configuredOptions, allFieldOptions);
 }

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

@@ -29,7 +29,8 @@ import {
   UiSchemaEnumItem,
 } from '../../internal/utils/enumOptionsUtils';
 import { mergeItemMetaTreeForAssignValue } from '../FieldAssignValueInput';
-import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
+import { pickOperatorStyle as pickStyle, resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
+import { limitAssociationMetaTree } from './metaTreeAssociationDepth';
 
 const { DateFilterDynamicComponent: DateFilterDynamicComponentLazy } = lazy(
   () => import('../../models/blocks/filter-form/fields/date-time/components/DateFilterDynamicComponent'),
@@ -49,6 +50,14 @@ export interface LinkageFilterItemProps {
   model: FlowModel;
   /** 向变量树额外注入节点（置于根部） */
   extraMetaTree?: MetaTreeNode[];
+  maxAssociationFieldDepth?: number;
+}
+
+function limitMetaTreeIfNeeded(nodes: MetaTreeNode[], maxAssociationFieldDepth?: number) {
+  if (typeof maxAssociationFieldDepth !== 'number') {
+    return nodes;
+  }
+  return limitAssociationMetaTree(nodes, { maxAssociationDepth: maxAssociationFieldDepth });
 }
 
 function createStaticInputRenderer(
@@ -221,7 +230,7 @@ export async function enhanceMetaTreeWithFilterableChildren(
  * LinkageFilterItem：左/右均为可变量输入，适用于联动规则等“前端逻辑”场景
  */
 export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((props) => {
-  const { value, model, extraMetaTree } = props;
+  const { value, model, extraMetaTree, maxAssociationFieldDepth } = props;
   const ctx = useFlowViewContext();
   const t = model.translate;
   const { path: leftPath, operator: selectedOperator, value: rightOperandValue } = value || {};
@@ -345,7 +354,8 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
     return (inputProps: { value?: any; onChange?: (v: any) => void } & Record<string, any>) => {
       const { value: inputValue, onChange, ...rest } = inputProps || {};
       const nextProps = { ...componentProps };
-      if ((!nextProps?.options || nextProps?.options.length === 0) && enumOptions.length > 0) {
+      const options = Array.isArray(nextProps.options) ? nextProps.options : undefined;
+      if ((!options || options.length === 0) && enumOptions.length > 0) {
         nextProps.options = enumOptions;
       }
       const normalizedValue = Array.isArray(inputValue)
@@ -363,7 +373,7 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
           {...rest}
           value={normalizedValue}
           onChange={onChange}
-          style={{ width: 200, ...(nextProps?.style || {}), ...(rest?.style || {}) }}
+          style={{ width: 200, ...pickStyle(nextProps.style), ...pickStyle(rest?.style) }}
         />
       );
 
@@ -386,13 +396,16 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
     return async () => {
       const baseMetaTree = (model?.context.getPropertyMetaTree() || ctx.getPropertyMetaTree()) as MetaTreeNode[];
       const mergedMetaTree = mergeExtraMetaTreeWithBase(baseMetaTree, extraMetaTree);
-      return [
-        { title: t('Constant'), name: 'constant', type: 'string', paths: ['constant'] },
-        { title: t('Null'), name: 'null', type: 'object', paths: ['null'] },
-        ...mergedMetaTree,
-      ];
+      return limitMetaTreeIfNeeded(
+        [
+          { title: t('Constant'), name: 'constant', type: 'string', paths: ['constant'] },
+          { title: t('Null'), name: 'null', type: 'object', paths: ['null'] },
+          ...mergedMetaTree,
+        ],
+        maxAssociationFieldDepth,
+      );
     };
-  }, [ctx, model, t, extraMetaTree]);
+  }, [ctx, model, t, extraMetaTree, maxAssociationFieldDepth]);
 
   // 左侧变量树：默认整棵 ctx（不追加 Constant/Null），确保可获取字段 interface
   const leftMetaTreeGetter = useCallback(async () => {
@@ -403,8 +416,9 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
       getFlowFieldInterfaceOptions(name, model.context.dataSourceManager, model.context.app?.dataSourceManager) as
         | FieldInterfaceDef
         | undefined;
-    return await enhanceMetaTreeWithFilterableChildren(merged, getFieldInterface);
-  }, [ctx, model, extraMetaTree]);
+    const enhanced = await enhanceMetaTreeWithFilterableChildren(merged, getFieldInterface);
+    return limitMetaTreeIfNeeded(enhanced, maxAssociationFieldDepth);
+  }, [ctx, model, extraMetaTree, maxAssociationFieldDepth]);
 
   // 右侧 converters：常量/空值特殊处理；变量沿用默认（表达式）
   const rightSideConverters = useMemo<Converters>(() => {

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

@@ -26,7 +26,8 @@ import {
 import _ from 'lodash';
 import { NumberPicker } from '@formily/antd-v5';
 import { enumToOptions, normalizeSelectRenderValue, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
-import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
+import { pickOperatorStyle as pickStyle, resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
+import { limitAssociationMetaTree } from './metaTreeAssociationDepth';
 
 const { DateFilterDynamicComponent: DateFilterDynamicComponentLazy } = lazy(
   () => import('../../models/blocks/filter-form/fields/date-time/components/DateFilterDynamicComponent'),
@@ -85,6 +86,14 @@ export interface VariableFilterItemProps {
    */
   rightMetaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
   ignoreFieldNames?: string[];
+  maxAssociationFieldDepth?: number;
+}
+
+function limitMetaTreeIfNeeded(nodes: MetaTreeNode[], maxAssociationFieldDepth?: number) {
+  if (typeof maxAssociationFieldDepth !== 'number') {
+    return nodes;
+  }
+  return limitAssociationMetaTree(nodes, { maxAssociationDepth: maxAssociationFieldDepth });
 }
 
 function createStaticInputRenderer(
@@ -260,7 +269,7 @@ function normalizeRightValueInput(input: unknown) {
  * 上下文筛选项组件
  */
 export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
-  ({ value, model, rightAsVariable, rightMetaTree, ignoreFieldNames }) => {
+  ({ value, model, rightAsVariable, rightMetaTree, ignoreFieldNames, maxAssociationFieldDepth }) => {
     // 使用 View 上下文，确保可访问 ctx.view 的异步子树
     const ctx = useFlowViewContext();
     const t = model.translate;
@@ -486,14 +495,15 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
       if (resolved && supportKeyword) {
         const { Comp, props: xProps } = resolved;
         const nextProps = { ...xProps };
-        if ((!nextProps?.options || nextProps?.options.length === 0) && enumOptions?.length) {
+        const options = Array.isArray(nextProps.options) ? nextProps.options : undefined;
+        if ((!options || options.length === 0) && enumOptions?.length) {
           nextProps.options = enumOptions;
         }
         const style = {
           flex: '1 1 40%',
           minWidth: 160,
           maxWidth: '100%',
-          ...(nextProps?.style || {}),
+          ...pickStyle(nextProps.style),
         };
         const normalized =
           Array.isArray(rightValue) && rightValue.every((v) => typeof v === 'string' || typeof v === 'number')
@@ -508,7 +518,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
           <div style={style}>
             <Comp
               {...nextProps}
-              style={{ width: '100%', ...(nextProps?.style || {}) }}
+              style={{ width: '100%', ...pickStyle(nextProps.style) }}
               value={normalized}
               onChange={(vals: any) => setRightValue(vals)}
             />
@@ -539,13 +549,22 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         const nodes: MetaTreeNode[] = Array.isArray(raw)
           ? (raw as MetaTreeNode[])
           : await (raw as () => Promise<MetaTreeNode[]>)();
-        return [
-          { title: t('Constant'), name: 'constant', type: 'string', paths: ['constant'], render: staticInputRenderer },
-          { title: t('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          ...nodes,
-        ];
+        return limitMetaTreeIfNeeded(
+          [
+            {
+              title: t('Constant'),
+              name: 'constant',
+              type: 'string',
+              paths: ['constant'],
+              render: staticInputRenderer,
+            },
+            { title: t('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
+            ...nodes,
+          ],
+          maxAssociationFieldDepth,
+        );
       };
-    }, [rightMetaTree, ctx, staticInputRenderer, NullComponent, t]);
+    }, [rightMetaTree, ctx, staticInputRenderer, NullComponent, t, maxAssociationFieldDepth]);
 
     // 当启用右侧变量输入时，构造 VariableInput 的 converters：
     // - 变量模式：返回 null 让 VariableInput 渲染 VariableTag
@@ -629,9 +648,9 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         for (const n of nodes) {
           out.push(await enhanceNode(n));
         }
-        return out;
+        return limitMetaTreeIfNeeded(out, maxAssociationFieldDepth);
       };
-    }, [getFieldInterface, model]);
+    }, [getFieldInterface, model, maxAssociationFieldDepth]);
 
     return (
       <Space wrap style={{ width: '100%' }}>

package/src/flow/components/filter/__tests__/fieldsToOptions.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 } from 'vitest';
+
+import { fieldsToOptions } from '../fieldsToOptions';
+
+describe('fieldsToOptions', () => {
+  it('skips nested fields when target collection is unavailable', () => {
+    const field = {
+      name: 'space',
+      type: 'belongsTo',
+      target: 'spaces',
+      title: 'Space',
+      interface: 'm2o',
+      filterable: true,
+      uiSchema: {},
+      getInterfaceOptions: () => ({
+        filterable: {
+          nested: true,
+          operators: [{ value: '$eq', label: 'is' }],
+        },
+      }),
+      getFields: () => {
+        throw new Error('Target collection spaces not found for field space');
+      },
+    };
+
+    expect(() => fieldsToOptions([field], 1, [], (key: string) => key)).not.toThrow();
+    expect(fieldsToOptions([field], 1, [], (key: string) => key)).toEqual([
+      {
+        name: 'space',
+        type: 'belongsTo',
+        target: 'spaces',
+        title: 'Space',
+        schema: {},
+        operators: [{ value: '$eq', label: 'is' }],
+        children: [],
+      },
+    ]);
+  });
+});