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

package/src/flow/models/base/__tests__/AssociationFieldGroupModel.test.ts

@@ -0,0 +1,86 @@
+/**
+ * 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 { afterEach, describe, expect, it, vi } from 'vitest';
+import { DisplayItemModel } from '@nocobase/flow-engine';
+import { AssociationFieldGroupModel } from '../AssociationFieldGroupModel';
+
+function createCollection(name: string, fields: any[]) {
+  return {
+    name,
+    dataSourceKey: 'main',
+    getFields: () => fields,
+    getToOneAssociationFields: () => fields.filter((field) => field?.type === 'belongsTo' || field?.type === 'hasOne'),
+  };
+}
+
+describe('AssociationFieldGroupModel', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('limits display association fields to relation / relation / field', () => {
+    vi.spyOn(DisplayItemModel, 'getDefaultBindingByField').mockReturnValue({ modelName: 'InputFieldModel' } as any);
+
+    const companies = createCollection('companies', [
+      { name: 'title', title: 'Company title', interface: 'input', type: 'string' },
+    ]);
+    const departments = createCollection('departments', [
+      { name: 'name', title: 'Department name', interface: 'input', type: 'string' },
+      {
+        name: 'company',
+        title: 'Company',
+        interface: 'm2o',
+        type: 'belongsTo',
+        target: 'companies',
+        targetCollection: companies,
+        isAssociationField: () => true,
+      },
+    ]);
+    const users = createCollection('users', [
+      {
+        name: 'department',
+        title: 'Department',
+        interface: 'm2o',
+        type: 'belongsTo',
+        target: 'departments',
+        targetCollection: departments,
+        isAssociationField: () => true,
+      },
+    ]);
+    const posts = createCollection('posts', [
+      {
+        name: 'user',
+        title: 'User',
+        interface: 'm2o',
+        type: 'belongsTo',
+        target: 'users',
+        targetCollection: users,
+        isAssociationField: () => true,
+      },
+    ]);
+
+    const ctx = {
+      collection: posts,
+      t: (key: string) => key,
+    } as any;
+
+    const firstLevel = AssociationFieldGroupModel.defineChildren(ctx) as any[];
+    const firstChildren = firstLevel[0].children();
+    const firstAssociationGroup = firstChildren.find((item) => item.key === 'user-children-associationField');
+    const secondLevel = firstAssociationGroup.children;
+    const secondChildren = secondLevel[0].children();
+    const secondFieldsGroup = secondChildren.find((item) => item.key === 'user.department-children-collectionField');
+
+    expect(secondChildren.map((item) => item.key)).toContain('user.department-children-collectionField');
+    expect(secondChildren.map((item) => item.key)).not.toContain('user.department-children-associationField');
+    expect(secondFieldsGroup.children.map((item) => item.key)).toContain('c-user.department.name');
+    expect(secondFieldsGroup.children.map((item) => item.key)).not.toContain('c-user.department.company');
+  });
+});

package/src/flow/models/base/__tests__/GridModel.render.test.tsx

@@ -0,0 +1,53 @@
+/**
+ * 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 { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { render } from '@testing-library/react';
+import React from 'react';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { GridModel } from '../GridModel';
+
+describe('GridModel.render', () => {
+  let engine: FlowEngine;
+
+  beforeEach(async () => {
+    engine = new FlowEngine();
+    engine.registerModels({ GridModel });
+    await engine.flowSettings.disable();
+  });
+
+  it('renders the Space wrapper as block-level flex to avoid inline baseline spacing', () => {
+    const item = engine.createModel({ use: 'FlowModel', uid: 'item-1' });
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-render',
+      props: {
+        rows: {
+          row1: [['item-1']],
+        },
+        sizes: {
+          row1: [24],
+        },
+        rowGap: 16,
+      },
+      structure: {} as any,
+    });
+    (model as any).subModels = { items: [item] };
+
+    expect(Object.keys((model as any).getVisibleLayout().rows)).toEqual(['row1']);
+
+    const { container } = render(<FlowEngineProvider engine={engine}>{model.render()}</FlowEngineProvider>);
+    const space = container.querySelector('.ant-space') as HTMLElement;
+
+    expect(space).toBeTruthy();
+    expect(space.style.width).toBe('100%');
+    expect(space.style.marginBottom).toBe('16px');
+    expect(space.style.display).toBe('flex');
+  });
+});

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;

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

@@ -22,7 +22,12 @@ import { CollectionBlockModel, FieldModel } from '../../base';
 import { RecordSelectFieldModel } from '../../fields/AssociationFieldModel/RecordSelectFieldModel';
 import { normalizeAssociationFieldNames } from '../../fields/AssociationFieldModel/recordSelectShared';
 import { FilterManager } from '../filter-manager';
-import { getAllDataModels, getDefaultOperator, isFilterValueEmpty } from '../filter-manager/utils';
+import {
+  getAllDataModels,
+  getDefaultOperator,
+  getFilterFormOperatorMeta,
+  isFilterValueEmpty,
+} from '../filter-manager/utils';
 import { FilterFormFieldModel } from './fields';
 import { normalizeFilterValueByOperator } from './valueNormalization';
 
@@ -51,7 +56,11 @@ 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;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
 
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;
@@ -449,15 +458,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
 
   private getCurrentOperatorMeta() {
     const operator = getDefaultOperator(this);
-    if (!operator) return null;
-
-    const operatorList = this.collectionField?.filterable?.operators;
-
-    if (!Array.isArray(operatorList)) {
-      return null;
-    }
-
-    return operatorList.find((op) => op.value === operator) || null;
+    return getFilterFormOperatorMeta(this, operator);
   }
 
   onInit(options: any) {
@@ -530,7 +531,8 @@ export class FilterFormItemModel extends FilterableItemModel<{
     rawValue = this.normalizeAssociationFilterValue(rawValue, fieldModel);
     const operatorMeta = this.getCurrentOperatorMeta();
     if (operatorMeta?.noValue) {
-      const options = operatorMeta?.schema?.['x-component-props']?.options;
+      const componentProps = operatorMeta?.schema?.['x-component-props'];
+      const options = isRecord(componentProps) ? componentProps.options : undefined;
       if (Array.isArray(options)) {
         return rawValue;
       }

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/__tests__/getDefaultOperator.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, expect, it, vi } from 'vitest';
 
-import { getDefaultOperator } from '../utils';
+import { getDefaultOperator, getFilterFormOperatorList } from '../utils';
 
 describe('getDefaultOperator', () => {
   it('returns model.operator when it exists', () => {
@@ -66,4 +66,38 @@ describe('getDefaultOperator', () => {
     expect(result).toBe('$includes');
     expect(getStepParams).toHaveBeenCalledWith('filterFormItemSettings', 'defaultOperator');
   });
+
+  it('falls back to field interface operators when field operators are empty', () => {
+    const getStepParams = vi.fn().mockReturnValue(undefined);
+    const model = {
+      getStepParams,
+      subModels: {},
+      collectionField: {
+        interface: 'id',
+        type: 'bigInt',
+        filterable: { operators: [] },
+      },
+      context: {
+        dataSourceManager: {
+          collectionFieldInterfaceManager: {
+            getFieldInterface: vi.fn(() => ({
+              filterable: {
+                operators: [
+                  { label: 'is', value: '$eq', selected: true },
+                  {
+                    label: 'is any of',
+                    value: '$in',
+                    schema: { 'x-component': 'MultipleKeywordsInput' },
+                  },
+                ],
+              },
+            })),
+          },
+        },
+      },
+    } as any;
+
+    expect(getDefaultOperator(model)).toBe('$eq');
+    expect(getFilterFormOperatorList(model).map((item) => item.value)).toEqual(['$eq', '$in']);
+  });
 });

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