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

package/src/flow/models/blocks/assign-form/AssignFormGridModel.tsx

@@ -12,11 +12,16 @@ import { AddSubModelButton, FlowSettingsButton, tExpr, EditableItemModel } from
 import { SettingOutlined } from '@ant-design/icons';
 import { FormGridModel } from '../form/FormGridModel';
 
+const MAX_ASSIGN_FORM_ASSOCIATION_FIELD_DEPTH = 2;
+
 // 使用范型准确标注 subModels.items 的类型
 export class AssignFormGridModel extends FormGridModel {
   renderAddSubModelButton() {
     const collection = (this.context as any)?.collection;
     const fields = collection?.getFields?.() || [];
+    const associationDepth = this.context.prefixFieldPath
+      ? this.context.prefixFieldPath.split('.').filter(Boolean).length
+      : 0;
     // 过滤主键/过滤键字段，避免产生“更新主键”的无效配置
     const pk = typeof collection?.getPrimaryKey === 'function' ? collection.getPrimaryKey() : undefined;
     const filterKey = collection?.filterTargetKey;
@@ -29,6 +34,12 @@ export class AssignFormGridModel extends FormGridModel {
     };
     const items = fields
       .filter((field: any) => !isForbidden(field?.name))
+      .filter((field: any) => {
+        if (associationDepth < MAX_ASSIGN_FORM_ASSOCIATION_FIELD_DEPTH) {
+          return true;
+        }
+        return !(field?.isAssociationField?.() || field?.target || field?.targetCollection);
+      })
       .map((field: any) => {
         const fullName = field.name as string;
         const label = field.title || field.name;
@@ -111,7 +122,7 @@ export class AssignFormGridModel extends FormGridModel {
       return;
     }
     const fieldModel = binding.modelName;
-    const created = this.flowEngine.createModel({
+    const created = this.addSubModel('items', {
       use: 'AssignFormItemModel',
       stepParams: {
         fieldSettings: {
@@ -137,8 +148,6 @@ export class AssignFormGridModel extends FormGridModel {
           },
         },
       },
-      parentId: this.uid,
-      subKey: 'items',
     });
     created['assignValue'] = value;
   }

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -86,6 +86,14 @@ function getAssignFormTempFieldRefreshKey(originField: AssignFormTempOriginField
   ].join('|');
 }
 
+function normalizeAssignFormInputValue(value: unknown) {
+  if (!value || typeof value !== 'object' || !('target' in value)) {
+    return value;
+  }
+  const target = (value as { target?: { value?: unknown } }).target;
+  return target && 'value' in target ? target.value : value;
+}
+
 /**
  * 使用 FormItemModel 的“表单项”包装，内部渲染 VariableInput，并将“常量”映射到临时字段模型。
  */
@@ -230,7 +238,6 @@ export class AssignFormItemModel extends FormItemModel {
         fm?.setProps?.({
           disabled: false,
           readPretty: false,
-          pattern: 'editable',
           updateAssociation: false,
           multiple: multi,
         });
@@ -260,9 +267,12 @@ export class AssignFormItemModel extends FormItemModel {
           if (fm) {
             fm.setProps?.({
               value: inputProps?.value,
-              onChange: (...args: any[]) => {
-                const next = args && args.length ? args[0] : undefined;
-                inputProps?.onChange?.(next);
+              onChange: (...args: unknown[]) => {
+                const nextArg = args && args.length ? args[0] : undefined;
+                const nextValue = normalizeAssignFormInputValue(nextArg);
+                fm.setProps?.({ value: nextValue });
+                this.assignValue = nextValue;
+                inputProps?.onChange?.(nextValue);
               },
             });
           }

package/src/flow/models/blocks/assign-form/__tests__/assignFieldValuesFlow.editor.test.tsx

@@ -0,0 +1,216 @@
+/**
+ * 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 { App, ConfigProvider } from 'antd';
+import { describe, expect, it } from 'vitest';
+import { render, screen, userEvent, waitFor } from '@nocobase/test/client';
+import {
+  FlowEngine,
+  FlowEngineProvider,
+  FlowRuntimeContext,
+  FlowSettingsContextProvider,
+  type FlowModel,
+  type IFlowModelRepository,
+} from '@nocobase/flow-engine';
+import { AssignFormGridModel } from '../AssignFormGridModel';
+import { AssignFormItemModel } from '../AssignFormItemModel';
+import { AssignFormModel } from '../AssignFormModel';
+import { createAssignFieldValuesStep } from '../assignFieldValuesFlow';
+import { InputFieldModel } from '../../../fields/InputFieldModel';
+import { VariableFieldFormModel } from '../../../fields/VariableFieldFormModel';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  async findOne(): Promise<Record<string, any> | null> {
+    return null;
+  }
+
+  async save(model: FlowModel): Promise<Record<string, any>> {
+    return { uid: model.uid };
+  }
+
+  async destroy(): Promise<boolean> {
+    return true;
+  }
+
+  async move(): Promise<void> {}
+
+  async duplicate(): Promise<Record<string, any> | null> {
+    return null;
+  }
+}
+
+describe('assignFieldValuesFlow (editor)', () => {
+  it('repairs AssignFormModel resource init and clears cached collection', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+
+    const dsm = engine.context.dataSourceManager;
+    const main = dsm.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = dsm.getCollection('main', 'users');
+    expect(users?.name).toBe('users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign',
+    });
+    action.setStepParams('assignSettings', 'assignFieldValues', { assignedValues: { nickname: '1111' } });
+
+    const existing = engine.createModel<AssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-assign',
+      parentId: action.uid,
+      subKey: 'assignForm',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing',
+          },
+        },
+      },
+    });
+    expect(existing.context.collection).toBeUndefined();
+
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const schema = step.uiSchema();
+    const Editor = schema.editor?.['x-component'] as React.ComponentType;
+    expect(Editor).toBeTypeOf('function');
+
+    const flowSettingsCtx = new FlowRuntimeContext(action as any, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.getStepParams('resourceSettings', 'init')).toEqual({
+        dataSourceKey: 'main',
+        collectionName: 'users',
+      });
+      expect(form?.context.collection?.name).toBe('users');
+      expect(form?.context.collection?.getFields?.().length).toBeGreaterThan(0);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('nickname')).toBeInTheDocument();
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.subModels.grid.subModels.items.length).toBe(1);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByDisplayValue('1111')).toBeInTheDocument();
+    });
+
+    const input = screen.getByDisplayValue('1111') as HTMLInputElement;
+    await userEvent.clear(input);
+    await userEvent.type(input, '2222');
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.getAssignedValues()).toEqual({ nickname: '2222' });
+    });
+  });
+
+  it('does not clear delegated parent resource cache when repairing AssignFormModel init', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({ AssignFormModel, AssignFormGridModel, AssignFormItemModel, InputFieldModel });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+
+    const dsm = engine.context.dataSourceManager;
+    const main = dsm.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = dsm.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-parent-resource',
+    });
+
+    let resourceCreateCount = 0;
+    action.context.defineProperty('resource', {
+      get: () => ({ id: ++resourceCreateCount }),
+    });
+    const cachedResource = action.context.resource;
+
+    engine.createModel<AssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-assign-parent-resource',
+      parentId: action.uid,
+      subKey: 'assignForm',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing',
+          },
+        },
+      },
+    });
+
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const schema = step.uiSchema();
+    const Editor = schema.editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action as any, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.getStepParams('resourceSettings', 'init')).toEqual({
+        dataSourceKey: 'main',
+        collectionName: 'users',
+      });
+    });
+
+    expect(action.context.resource).toBe(cachedResource);
+    expect(resourceCreateCount).toBe(1);
+  });
+});

package/src/flow/models/blocks/assign-form/assignFieldValuesFlow.tsx

@@ -15,7 +15,7 @@ import {
   useFlowEngine,
   useFlowSettingsContext,
 } from '@nocobase/flow-engine';
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect } from 'react';
 import { CollectionActionModel } from '../../base/CollectionActionModel';
 import { RecordActionModel } from '../../base/RecordActionModel';
 import { AssignFormModel } from './AssignFormModel';
@@ -38,6 +38,9 @@ type AssignFieldValuesModel = {
   uid: string;
   assignFormUid?: string;
   context?: AssignFieldValuesContext;
+  subModels?: {
+    assignForm?: AssignFormModel;
+  };
   getStepParams?: (flowKey: string, stepKey: string) => { assignedValues?: AssignedValues } | undefined;
   setStepParams?: (flowKey: string, stepKey: string, params: { assignedValues: AssignedValues }) => void;
 };
@@ -62,6 +65,81 @@ function getResourceInit(ctx: AssignFieldValuesContext): { dataSourceKey: string
   return dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
 }
 
+function resolveInitFromFlowSettings(
+  blockModel: unknown,
+  actionContext: AssignFieldValuesContext | undefined,
+): { dataSourceKey: string; collectionName: string } | undefined {
+  const maybeBlockCollection = (blockModel as { collection?: { dataSourceKey?: string; name?: string } } | undefined)
+    ?.collection;
+  const collection = maybeBlockCollection || getContextCollection(actionContext);
+  const dsKey = collection?.dataSourceKey;
+  const collName = collection?.name;
+  return dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
+}
+
+function isValidResourceInit(init: unknown): init is {
+  dataSourceKey: string;
+  collectionName: string;
+} {
+  if (!init || typeof init !== 'object') return false;
+  const obj = init as { dataSourceKey?: unknown; collectionName?: unknown };
+  return (
+    typeof obj.dataSourceKey === 'string' &&
+    !!obj.dataSourceKey &&
+    typeof obj.collectionName === 'string' &&
+    !!obj.collectionName
+  );
+}
+
+type LocalCacheContext = {
+  _observableCache?: Record<string, unknown>;
+  _cache?: Record<string, unknown>;
+  _pending?: Record<string, unknown>;
+};
+
+function toLocalCacheContext(context: unknown): LocalCacheContext | undefined {
+  return context && typeof context === 'object' ? (context as LocalCacheContext) : undefined;
+}
+
+function clearOwnContextCache(context: unknown, key: string) {
+  const localContext = toLocalCacheContext(context);
+  if (!localContext) {
+    return;
+  }
+  delete localContext._observableCache?.[key];
+  delete localContext._cache?.[key];
+  delete localContext._pending?.[key];
+}
+
+function clearResourceContextCache(model: { context?: unknown } | undefined) {
+  clearOwnContextCache(model?.context, 'dataSource');
+  clearOwnContextCache(model?.context, 'collection');
+  clearOwnContextCache(model?.context, 'resource');
+  clearOwnContextCache(model?.context, 'association');
+}
+
+function resolveAssignFormModel(ctx: {
+  model: AssignFieldValuesModel;
+  engine: {
+    getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+    findModelByParentId?: (parentId: string, subKey: string) => AssignFormModel | undefined | null;
+  };
+}) {
+  if (ctx.model.assignFormUid) {
+    const form = ctx.engine.getModel?.(ctx.model.assignFormUid, true);
+    if (form) {
+      return form;
+    }
+  }
+
+  const localForm = ctx.model.subModels?.assignForm;
+  if (localForm) {
+    return localForm;
+  }
+
+  return ctx.engine.findModelByParentId?.(ctx.model.uid, 'assignForm') || undefined;
+}
+
 export function createAssignFormSubModelOptions(ctx: AssignFieldValuesContext) {
   return {
     async: true,
@@ -114,21 +192,52 @@ function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext
   const { model, blockModel } = useFlowSettingsContext();
   const action = model as AssignFieldValuesModel;
   const engine = useFlowEngine();
-  const initializedRef = useRef(false);
   const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
 
   useEffect(() => {
     let cancelled = false;
     const loadAssignForm = async () => {
+      const init = resolveInitFromFlowSettings(blockModel, action?.context);
       const loaded = (await engine.loadOrCreateModel(
-        {
-          parentId: action.uid,
-          subKey: 'assignForm',
-          use: 'AssignFormModel',
-        },
+        init
+          ? {
+              parentId: action.uid,
+              subKey: 'assignForm',
+              use: 'AssignFormModel',
+              stepParams: { resourceSettings: { init } },
+            }
+          : {
+              parentId: action.uid,
+              subKey: 'assignForm',
+              use: 'AssignFormModel',
+            },
         { skipSave: !model.context.flowSettingsEnabled },
       )) as AssignFormModel;
       if (cancelled) return;
+
+      if (isValidResourceInit(init)) {
+        const existingInit = loaded.getStepParams?.('resourceSettings', 'init');
+        // Ensure `resourceSettings.init` is available before first render to avoid cached undefined `collection`
+        if (
+          !isValidResourceInit(existingInit) ||
+          existingInit.dataSourceKey !== init.dataSourceKey ||
+          existingInit.collectionName !== init.collectionName
+        ) {
+          loaded.setStepParams?.('resourceSettings', 'init', init);
+        }
+        clearResourceContextCache(loaded);
+        clearResourceContextCache(loaded.subModels?.grid);
+      }
+
+      const prev = action.getStepParams?.(props.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
+      loaded.setInitialAssignedValues(prev?.assignedValues || {});
+
+      const isBulkCollectionAction = model instanceof CollectionActionModel && !(model instanceof RecordActionModel);
+      const isBulk = props.clearRecordContext || isBulkCollectionAction;
+      if (isBulk && loaded.context?.defineProperty) {
+        loaded.context.defineProperty('record', { get: () => undefined, cache: false });
+      }
+
       setFormModel(loaded);
       action.assignFormUid = loaded?.uid || action.assignFormUid;
     };
@@ -136,31 +245,15 @@ function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext
     return () => {
       cancelled = true;
     };
-  }, [action, engine, model.context.flowSettingsEnabled]);
-
-  useEffect(() => {
-    if (initializedRef.current) return;
-    if (!formModel) return;
-
-    const prev = action.getStepParams?.(props.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
-    const coll = blockModel?.collection || getContextCollection(action?.context);
-    const dsKey = coll?.dataSourceKey;
-    const collName = coll?.name;
-    if (dsKey && collName) {
-      formModel.setStepParams('resourceSettings', 'init', {
-        dataSourceKey: dsKey,
-        collectionName: collName,
-      });
-    }
-    formModel.setInitialAssignedValues(prev?.assignedValues || {});
-
-    const isBulk =
-      props.clearRecordContext || (action instanceof CollectionActionModel && !(action instanceof RecordActionModel));
-    if (isBulk && formModel.context?.defineProperty) {
-      formModel.context.defineProperty('record', { get: () => undefined, cache: false });
-    }
-    initializedRef.current = true;
-  }, [action, blockModel?.collection, formModel, props.clearRecordContext, props.settingsFlowKey]);
+  }, [
+    action,
+    blockModel,
+    engine,
+    model,
+    model.context.flowSettingsEnabled,
+    props.clearRecordContext,
+    props.settingsFlowKey,
+  ]);
 
   return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
 }
@@ -187,14 +280,23 @@ export function createAssignFieldValuesStep(options: AssignFieldValuesStepOption
         },
       };
     },
-    async beforeParamsSave(ctx: {
-      model: AssignFieldValuesModel;
-      engine: {
-        getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
-      };
-    }) {
-      const form = ctx.model.assignFormUid ? ctx.engine.getModel?.(ctx.model.assignFormUid, true) : undefined;
-      if (!form) return;
+    async beforeParamsSave(
+      ctx: {
+        model: AssignFieldValuesModel;
+        engine: {
+          getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+          findModelByParentId?: (parentId: string, subKey: string) => AssignFormModel | undefined | null;
+        };
+      },
+      params?: { assignedValues?: AssignedValues },
+      previousParams?: { assignedValues?: AssignedValues },
+    ) {
+      const form = resolveAssignFormModel(ctx);
+      if (!form) {
+        const assignedValues = params?.assignedValues || previousParams?.assignedValues || {};
+        ctx.model.setStepParams?.(options.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY, { assignedValues });
+        return;
+      }
       if (options.validateBeforeSave) {
         await form.form?.validateFields?.();
       }

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

@@ -51,7 +51,7 @@ const getTargetFilterableFields = (field: any, collection?: Collection, model?:
   return (targetCollection.getFields() || []).filter((childField: any) => childField?.filterable);
 };
 
-const MAX_ASSOCIATION_DEPTH = 5;
+const MAX_ASSOCIATION_DEPTH = 2;
 
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;

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

@@ -136,9 +136,13 @@ describe('FilterFormItemModel defineChildren association fields', () => {
     );
     const managerGroups = await managerAssociation.children();
     const managerFieldsGroup = managerGroups.find((group: any) => group.key === 'department.manager-fields');
+    const managerAssociationGroup = managerGroups.find(
+      (group: any) => group.key === 'department.manager-relation-fields',
+    );
 
     const managerFieldKeys = (managerFieldsGroup?.children || []).map((item: any) => item.key);
     expect(managerFieldKeys).toContain('department.manager.name');
+    expect(managerAssociationGroup).toBeUndefined();
 
     const targetItem = managerFieldsGroup?.children?.find((item: any) => item.key === 'department.manager.name');
     const createOptions = await targetItem.createModelOptions();
@@ -200,7 +204,8 @@ describe('FilterFormItemModel defineChildren association fields', () => {
     });
 
     const ds = engine.dataSourceManager.getDataSource('main');
-    ds!.addCollection({
+    expect(ds).toBeTruthy();
+    ds?.addCollection({
       name: 'users',
       filterTargetKey: 'id',
       fields: [{ name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } }],

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]);
   };