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

package/src/flow/models/actions/__tests__/AssignFormRefill.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
-import { UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
+import { FormSubmitActionModel, UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
 
 /**
  * 精简版 AssignFormModel（仅用于单测）：
@@ -52,4 +52,119 @@ describe('AssignForm value refill and save (beforeParamsSave)', () => {
     const saved = action.getStepParams('assignSettings', 'assignFieldValues');
     expect(saved?.assignedValues).toEqual({ nickname: 'Alice', score: 99 });
   });
+
+  it('UpdateRecordActionModel: saves assignedValues from assignForm subModel when assignFormUid is not ready', async () => {
+    const root = new FlowEngine();
+    root.registerModels({ UpdateRecordActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<UpdateRecordActionModel>({ use: 'UpdateRecordActionModel', uid: 'act-u-sub' });
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-u-sub',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ nickname: 'Bob' });
+    action.setSubModel('assignForm', form);
+
+    const flow = action.getFlow('assignSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+
+    await step.beforeParamsSave({ engine: root, model: action }, {}, {});
+
+    const saved = action.getStepParams('assignSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ nickname: 'Bob' });
+  });
+
+  it('UpdateRecordActionModel: keeps previous assignedValues when AssignForm is unavailable during save', async () => {
+    const root = new FlowEngine();
+    root.registerModels({ UpdateRecordActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<UpdateRecordActionModel>({ use: 'UpdateRecordActionModel', uid: 'act-u-missing' });
+    action.setStepParams('assignSettings', 'assignFieldValues', {});
+
+    const flow = action.getFlow('assignSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+
+    await step.beforeParamsSave(
+      { engine: root, model: action },
+      {},
+      {
+        assignedValues: { nickname: 'Previous' },
+      },
+    );
+
+    const saved = action.getStepParams('assignSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ nickname: 'Previous' });
+  });
+
+  it('FormSubmitActionModel: reuses assignFieldValues step and saves assignedValues from AssignForm', async () => {
+    const root = new FlowEngine();
+
+    root.registerModels({ FormSubmitActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<FormSubmitActionModel>({ use: 'FormSubmitActionModel', uid: 'submit-u' });
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'submit-form-u',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ status: 'published' });
+    action.assignFormUid = form.uid;
+
+    const flow = action.getFlow('submitSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+    expect(step?.beforeParamsSave).toBeTypeOf('function');
+
+    await step.beforeParamsSave({ engine: root, model: action });
+
+    const saved = action.getStepParams('submitSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ status: 'published' });
+  });
+
+  it('FormSubmitActionModel: saves assignedValues from assignForm subModel when assignFormUid is not ready', async () => {
+    const root = new FlowEngine();
+    root.registerModels({ FormSubmitActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<FormSubmitActionModel>({ use: 'FormSubmitActionModel', uid: 'submit-u-sub' });
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'submit-form-u-sub',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ status: 'draft' });
+    action.setSubModel('assignForm', form);
+
+    const flow = action.getFlow('submitSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+
+    await step.beforeParamsSave({ engine: root, model: action }, {}, {});
+
+    const saved = action.getStepParams('submitSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ status: 'draft' });
+  });
+
+  it('FormSubmitActionModel: keeps previous assignedValues when AssignForm is unavailable during save', async () => {
+    const root = new FlowEngine();
+    root.registerModels({ FormSubmitActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<FormSubmitActionModel>({ use: 'FormSubmitActionModel', uid: 'submit-u-missing' });
+    action.setStepParams('submitSettings', 'assignFieldValues', {});
+
+    const flow = action.getFlow('submitSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+
+    await step.beforeParamsSave(
+      { engine: root, model: action },
+      {},
+      {
+        assignedValues: { status: 'published' },
+      },
+    );
+
+    const saved = action.getStepParams('submitSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ status: 'published' });
+  });
 });

package/src/flow/models/base/ActionModel.tsx

@@ -80,7 +80,14 @@ ActionModel.registerFlow({
         };
       },
       defaultParams(ctx) {
-        return ctx.model.defaultProps;
+        const defaultProps = ctx.model.defaultProps || {};
+        if (!ctx.model.enableEditColor) {
+          return defaultProps;
+        }
+        return {
+          ...defaultProps,
+          color: ctx.model.props?.color ?? defaultProps.color ?? ctx.themeToken?.colorPrimary,
+        };
       },
       handler(ctx, params) {
         const { title, tooltip, ...rest } = params;

package/src/flow/models/base/AssociationFieldGroupModel.tsx

@@ -11,13 +11,20 @@ import { Collection, DisplayItemModel, FlowModel, FlowModelContext } from '@noco
 
 export class AssociationFieldGroupModel extends FlowModel {
   static itemModelName = 'DetailsItemModel';
+  static maxAssociationFieldDepth = 2;
   static defineChildren(ctx: FlowModelContext) {
     const itemModel = this.itemModelName;
-    const displayAssociationFields = (targetCollection: Collection, fieldPath = '') => {
+    const maxAssociationFieldDepth = this.maxAssociationFieldDepth ?? 2;
+    const displayAssociationFields = (targetCollection: Collection, fieldPath = '', associationDepth = 0) => {
+      if (associationDepth >= maxAssociationFieldDepth) {
+        return [];
+      }
+
       return targetCollection
         .getToOneAssociationFields()
         .map((field) => {
           const fPath = fieldPath ? `${fieldPath}.${field.name}` : field.name;
+          const nextAssociationDepth = associationDepth + 1;
           if (!field.targetCollection) {
             console.error(
               `AssociationFieldGroupModel: target collection ${field.target} not found for field ${field.name}`,
@@ -37,6 +44,12 @@ export class AssociationFieldGroupModel extends FlowModel {
                   children: field.targetCollection
                     .getFields()
                     .map((f) => {
+                      if (
+                        nextAssociationDepth >= maxAssociationFieldDepth &&
+                        (f.isAssociationField?.() || f.target || f.targetCollection)
+                      ) {
+                        return;
+                      }
                       const fp = `${fPath}.${f.name}`;
                       const binding = DisplayItemModel.getDefaultBindingByField(ctx, f, {
                         fallbackToTargetTitleField: true,
@@ -81,9 +94,13 @@ export class AssociationFieldGroupModel extends FlowModel {
                   key: `${fPath}-children-associationField`,
                   label: 'Display association fields',
                   type: 'group',
-                  children: (displayAssociationFields(field.targetCollection, fPath) || []).filter(Boolean),
+                  children: (
+                    displayAssociationFields(field.targetCollection, fPath, nextAssociationDepth) || []
+                  ).filter(Boolean),
                 },
-              ];
+              ].filter((item) => {
+                return item.key !== `${fPath}-children-associationField` || (item.children as any[])?.length > 0;
+              });
             },
           };
         })

package/src/flow/models/base/GridModel.tsx

@@ -1006,7 +1006,7 @@ export class GridModel<T extends { subModels: { items: FlowModel[] } } = Default
           <Space
             ref={this.gridContainerRef}
             direction={'vertical'}
-            style={{ width: '100%', marginBottom: this.props.rowGap }}
+            style={{ width: '100%', marginBottom: this.props.rowGap, display: 'flex' }}
             size={this.props.rowGap}
           >
             <DndProvider

package/src/flow/models/base/PageModel/ChildPageModel.tsx

@@ -49,7 +49,11 @@ export class ChildPageModel extends PageModel {
       throw new Error('Invalid drag event');
     }
 
-    this.flowEngine.moveModel(event.active.id, event.over.id);
+    if (event.active.id === event.over.id) {
+      return;
+    }
+
+    await this.flowEngine.moveModel(event.active.id, event.over.id);
   }
 
   render() {

package/src/flow/models/base/PageModel/PageModel.tsx

@@ -40,6 +40,15 @@ type PageModelStructure = {
   };
 };
 
+type CurrentRouteWithTabs = {
+  id?: string | number | null;
+  enableTabs?: boolean;
+};
+
+type PageModelContextWithRoute = {
+  currentRoute?: CurrentRouteWithTabs | null;
+};
+
 export class PageModel extends FlowModel<PageModelStructure> {
   tabBarExtraContent: { left?: ReactNode; right?: ReactNode } = {};
   private viewActivatedListener?: (_payload?: unknown) => void;
@@ -53,9 +62,15 @@ export class PageModel extends FlowModel<PageModelStructure> {
    * 根页面标签页开关以路由表为准，避免 flow model 里的旧配置覆盖路由管理设置。
    */
   private getEnableTabs(): boolean {
-    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
-    if (this.props.routeId != null && typeof routeEnableTabs === 'boolean') {
-      return routeEnableTabs;
+    const currentRoute = (this.context as PageModelContextWithRoute).currentRoute;
+    const routeId = this.props.routeId;
+    if (
+      routeId != null &&
+      currentRoute?.id != null &&
+      String(currentRoute.id) === String(routeId) &&
+      typeof currentRoute.enableTabs === 'boolean'
+    ) {
+      return currentRoute.enableTabs;
     }
     return !!this.props.enableTabs;
   }
@@ -77,16 +92,27 @@ export class PageModel extends FlowModel<PageModelStructure> {
         if (this.unmounted) return;
         // Only skip when explicitly inactive; treat "unknown" (undefined) as active for backward compatibility.
         if (getPageActive(this.context) === false) return;
-        const activeKey = this.getActiveTabKey();
-        if (activeKey) {
-          this.invokeTabModelLifecycleMethod(activeKey, 'onActive', forceRefresh);
-        }
+        this.activateCurrentTab(forceRefresh);
       })
       .catch(() => {
         // ignore
       });
   }
 
+  activateCurrentTab(forceRefresh = false) {
+    const activeKey = this.getActiveTabKey();
+    if (activeKey) {
+      this.invokeTabModelLifecycleMethod(activeKey, 'onActive', forceRefresh);
+    }
+  }
+
+  deactivateCurrentTab() {
+    const activeKey = this.props.tabActiveKey || this.getFirstTab()?.uid;
+    if (activeKey) {
+      this.invokeTabModelLifecycleMethod(activeKey, 'onInactive');
+    }
+  }
+
   onMount(): void {
     super.onMount();
     this.unmounted = false;
@@ -98,10 +124,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
     // We align this with the existing tab lifecycle by invoking `onActive` for the current tab blocks.
     if (!this.viewActivatedListener) {
       this.viewActivatedListener = (_payload?: unknown) => {
-        const activeKey = this.getActiveTabKey();
-        if (activeKey) {
-          this.invokeTabModelLifecycleMethod(activeKey, 'onActive');
-        }
+        this.activateCurrentTab();
       };
       this.flowEngine?.emitter?.on?.(VIEW_ACTIVATED_EVENT, this.viewActivatedListener);
     }
@@ -113,10 +136,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
       emitterActivatedVersion > 0 && emitterActivatedVersion !== this.lastSeenEmitterViewActivatedVersion;
     this.lastSeenEmitterViewActivatedVersion = emitterActivatedVersion;
     if (shouldCatchUp && getPageActive(this.context) !== false) {
-      const activeKey = this.getActiveTabKey();
-      if (activeKey) {
-        this.invokeTabModelLifecycleMethod(activeKey, 'onActive');
-      }
+      this.activateCurrentTab();
     }
 
     // When data is written within the same view, trigger an "active" lifecycle pass so blocks can refresh based on dirty.
@@ -141,11 +161,21 @@ export class PageModel extends FlowModel<PageModelStructure> {
     super.onUnmount();
   }
 
-  invokeTabModelLifecycleMethod(tabActiveKey: string, method: 'onActive' | 'onInactive', forceRefresh = false) {
+  invokeTabModelLifecycleMethod(
+    tabActiveKey: string | undefined,
+    method: 'onActive' | 'onInactive',
+    forceRefresh = false,
+  ) {
+    if (!tabActiveKey) {
+      return;
+    }
+
     if (method === 'onActive' && this.context?.pageInfo) {
       this.context.pageInfo.version = 'v2';
     }
-    const tabModel = this.flowEngine.getModel(tabActiveKey) as BasePageTabModel | undefined;
+    const tabModel =
+      this.findSubModel('tabs', (model) => model.uid === tabActiveKey) ||
+      (this.flowEngine.getModel(tabActiveKey) as BasePageTabModel | undefined);
 
     if (tabModel) {
       if (tabModel.context.tabActive) {
@@ -183,7 +213,10 @@ export class PageModel extends FlowModel<PageModelStructure> {
     const routePathname = this.flowEngine?.context?.route?.pathname;
     // In route-managed multi-view mode, only the top view in URL should mutate document.title.
     if (hasRouteNavigation && currentViewUid && typeof routePathname === 'string') {
-      const topViewUid = parsePathnameToViewParams(routePathname).at(-1)?.viewUid;
+      const layoutRoutePath = this.context?.layout?.routePath;
+      const topViewUid = parsePathnameToViewParams(routePathname, {
+        basePath: this.context?.layoutRoute?.basePathname || (layoutRoutePath?.startsWith('/') ? layoutRoutePath : ''),
+      }).at(-1)?.viewUid;
       if (topViewUid && topViewUid !== currentViewUid) {
         return;
       }

package/src/flow/models/base/PageModel/RootPageModel.tsx

@@ -68,22 +68,15 @@ export class RootPageModel extends PageModel {
     reaction(
       () => this.context.pageActive.value,
       () => {
+        if (this.context.view?.inputArgs?.activationControlledByLayout) {
+          this.mounted = true;
+          return;
+        }
         if (this.context.pageActive.value && this.mounted) {
-          const firstTab = this.subModels.tabs?.[0];
-          if (firstTab) {
-            this.setProps('tabActiveKey', firstTab.uid);
-            this.invokeTabModelLifecycleMethod(firstTab.uid, 'onActive', true);
-          }
+          this.activateCurrentTab(true);
         }
         if (this.context.pageActive.value === false) {
-          if (this.props.tabActiveKey) {
-            this.invokeTabModelLifecycleMethod(this.props.tabActiveKey, 'onInactive');
-          } else {
-            const firstTab = this.subModels.tabs?.[0];
-            if (firstTab) {
-              this.invokeTabModelLifecycleMethod(firstTab.uid, 'onInactive');
-            }
-          }
+          this.deactivateCurrentTab();
         }
         this.mounted = true;
       },

package/src/flow/models/base/PageModel/__tests__/ChildPageModel.test.ts

@@ -107,6 +107,18 @@ describe('ChildPageModel', () => {
       expect(mockFlowEngine.moveModel).toHaveBeenCalledWith('active-model-id', 'over-model-id');
     });
 
+    it('should ignore self-drop', async () => {
+      await childPageModel.handleDragEnd({
+        ...mockDragEndEvent,
+        over: {
+          ...(mockDragEndEvent.over as NonNullable<DragEndEvent['over']>),
+          id: 'active-model-id',
+        },
+      });
+
+      expect(mockFlowEngine.moveModel).not.toHaveBeenCalled();
+    });
+
     it('should handle case when over is null', async () => {
       const eventWithNullOver = {
         ...mockDragEndEvent,

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

@@ -47,6 +47,13 @@ vi.mock('@nocobase/flow-engine', () => {
       return [];
     }
 
+    findSubModel(key: string, callback: any) {
+      if (this.subModels[key]) {
+        return this.subModels[key].find(callback) || null;
+      }
+      return null;
+    }
+
     addSubModel() {}
     setSubModel() {}
 
@@ -260,6 +267,44 @@ describe('PageModel', () => {
     });
   });
 
+  describe('tab lifecycle', () => {
+    it('should invoke tab lifecycle on PageModel subModels before engine lookup', () => {
+      const blockOnActive = vi.fn();
+      const blockOnInactive = vi.fn();
+      const tabModel = {
+        uid: 'tab1',
+        context: {
+          tabActive: { value: false },
+        },
+        subModels: {
+          grid: {
+            mapSubModels: vi.fn((_key, callback) => {
+              callback({ onActive: blockOnActive, onInactive: blockOnInactive });
+            }),
+          },
+        },
+      };
+      (pageModel as any).subModels = { tabs: [tabModel] };
+      (pageModel as any).flowEngine = {
+        getModel: vi.fn(() => undefined),
+      };
+      (pageModel as any).context = {
+        pageInfo: {},
+        view: {
+          inputArgs: { pageActive: true },
+        },
+      };
+
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onActive', true);
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onInactive');
+
+      expect((pageModel as any).flowEngine.getModel).not.toHaveBeenCalled();
+      expect(tabModel.context.tabActive.value).toBe(false);
+      expect(blockOnActive).toHaveBeenCalledWith(true);
+      expect(blockOnInactive).toHaveBeenCalledWith(false);
+    });
+  });
+
   describe('renderTabs activeKey logic', () => {
     beforeEach(() => {
       // Mock mapTabs to avoid complex rendering logic inside it
@@ -455,6 +500,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: false,
         },
       };
@@ -479,6 +525,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: true,
         },
       };
@@ -495,6 +542,59 @@ describe('PageModel', () => {
         paddingBottom: 0,
       });
     });
+
+    it('should ignore stale desktop route enableTabs=false from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: true,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          enableTabs: false,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).not.toHaveBeenCalled();
+      expect(header.props.style).toMatchObject({
+        backgroundColor: 'var(--colorBgLayout)',
+        paddingBottom: 0,
+      });
+    });
+
+    it('should ignore stale desktop route enableTabs=true from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: false,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          enableTabs: true,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).not.toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).toHaveBeenCalled();
+      expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
+    });
   });
 
   describe('dirty refresh signal', () => {
@@ -554,7 +654,7 @@ describe('PageModel', () => {
       pageModel.onMount();
 
       expect(typeof listeners['view:activated']).toBe('function');
-      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive');
+      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive', false);
     });
   });
 
@@ -630,6 +730,7 @@ describe('PageModel', () => {
     it('should use page documentTitle when desktop route disables tabs even if flow model enables tabs', async () => {
       pageModel.props = { routeId: 'route-1', enableTabs: true, title: 'Route page title' } as any;
       (pageModel as any).context.currentRoute = {
+        id: 'route-1',
         enableTabs: false,
       };
       (pageModel as any).stepParams = {

package/src/flow/models/base/RouteModel.tsx

@@ -21,7 +21,7 @@ RouteModel.registerFlow({
         return {
           mode: 'embed',
           preventClose: true,
-          pageModelClass: 'RootPageModel',
+          pageModelClass: ctx.layout?.rootPageModelClass || 'RootPageModel',
         };
       },
     },

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');
+  });
+});