@nocobase/client-v2 3.0.0-alpha.1 → 3.0.0-alpha.12

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

@@ -9,11 +9,13 @@
 
 import { describe, expect, it } from 'vitest';
 import '../../../../index';
-import { FlowEngine } from '@nocobase/flow-engine';
+import { FilterableItemModel, FlowEngine } from '@nocobase/flow-engine';
 import { CollectionBlockModel } from '../../../base';
+import { CascadeSelectFieldModel } from '../../../fields/AssociationFieldModel/CascadeSelectFieldModel';
 import { InputFieldModel } from '../../../fields/InputFieldModel';
 import { NumberFieldModel } from '../../../fields/NumberFieldModel';
 import { FilterFormRecordSelectFieldModel } from '../fields/FilterFormRecordSelectFieldModel';
+import { FilterFormFieldModel } from '../fields/FilterFormFieldModel';
 import { FilterFormItemModel } from '../FilterFormItemModel';
 
 class DummyResource {
@@ -32,6 +34,20 @@ class DummyCollectionBlockModel extends CollectionBlockModel {
   }
 }
 
+class TestCascaderFilterFieldModel extends FilterFormFieldModel {}
+
+FilterableItemModel.bindModelToInterface('TestCascaderFilterFieldModel', ['testChinaRegion'], {
+  isDefault: true,
+  defaultProps: {
+    fieldNames: {
+      label: 'name',
+      value: 'code',
+    },
+    labelInValue: true,
+    multiple: false,
+  },
+});
+
 describe('FilterFormItemModel defineChildren association fields', () => {
   it('hides default operator setting for association filter fields', () => {
     const engine = new FlowEngine();
@@ -191,6 +207,348 @@ describe('FilterFormItemModel defineChildren association fields', () => {
     expect(filterItem.collectionField).toBeTruthy();
   });
 
+  it('lists filterable children from association field interfaces', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FilterFormItemModel: FilterFormItemModel as any,
+      DummyCollectionBlockModel,
+      InputFieldModel,
+      FilterFormRecordSelectFieldModel,
+    });
+    engine.context.defineProperty('t', {
+      value: (value: string) => (value === '{{t("Province/city/area name")}}' ? '省/市/区名称' : value),
+    });
+
+    const ds = engine.dataSourceManager.getDataSource('main');
+    ds?.addCollection({
+      name: 'students',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } },
+        {
+          name: 'studentName',
+          title: 'Student name',
+          type: 'string',
+          interface: 'input',
+          filterable: { operators: [] },
+        },
+        {
+          name: 'birthPlace',
+          title: 'Birth place',
+          type: 'belongsToMany',
+          interface: 'chinaRegion',
+          target: 'chinaRegions',
+          filterable: {
+            children: [
+              {
+                name: 'name',
+                title: '{{t("Province/city/area name")}}',
+                operators: 'string',
+                schema: {
+                  title: '{{t("Province/city/area name")}}',
+                  type: 'string',
+                  'x-component': 'Input',
+                },
+              },
+            ],
+          },
+        },
+      ],
+    });
+
+    const model = engine.createModel<DummyCollectionBlockModel>({
+      uid: 'students-block',
+      use: 'DummyCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'students',
+          },
+        },
+      },
+    });
+    const getFilterFields = model.getFilterFields.bind(model);
+    model.getFilterFields = async () => {
+      const fields = await getFilterFields();
+      return fields.map((field: any) =>
+        field.name === 'birthPlace'
+          ? {
+              name: field.name,
+              title: field.title,
+              type: field.type,
+              interface: field.interface,
+              target: field.target,
+              filterable: field.filterable,
+              isAssociationField: () => true,
+            }
+          : field,
+      ) as any;
+    };
+
+    const children = (await FilterFormItemModel.defineChildren({
+      blockGridModel: {
+        filterSubModels: (_key: string, predicate: (item: any) => boolean) => [model].filter(predicate),
+      },
+      t: (value: string) => value,
+    } as any)) as any[];
+
+    const groups = await children[0].children();
+    const fieldsGroup = groups.find((group: any) => group.key === 'fields');
+    const associationGroup = groups.find((group: any) => group.key === 'relation-fields');
+    const fieldKeys = (fieldsGroup?.children || []).map((item: any) => item.key);
+    const associationKeys = (associationGroup?.children || []).map((item: any) => item.key);
+
+    expect(fieldKeys).toContain('studentName');
+    expect(associationKeys).toContain('birthPlace-associationField');
+    expect(associationKeys).not.toContain('studentName-associationField');
+
+    const regionAssociation = associationGroup?.children?.find(
+      (item: any) => item.key === 'birthPlace-associationField',
+    );
+    const regionGroups = await regionAssociation.children();
+    const regionFieldsGroup = regionGroups.find((group: any) => group.key === 'birthPlace-fields');
+    const regionNameItem = regionFieldsGroup?.children?.find((item: any) => item.key === 'birthPlace.name');
+
+    expect(regionNameItem?.label).toBe('Birth place / 省/市/区名称');
+
+    const createOptions = await regionNameItem.createModelOptions();
+    const filterItem = engine.createModel({
+      uid: 'filter-item-region-name',
+      ...createOptions,
+    } as any) as unknown as FilterFormItemModel;
+
+    expect(filterItem.fieldPath).toBe('birthPlace.name');
+    expect(filterItem.context.filterField).toMatchObject({
+      name: 'name',
+      title: 'Birth place / 省/市/区名称',
+      interface: 'input',
+      type: 'string',
+    });
+    expect(filterItem.context.filterField?.filterable?.operators).toBe('string');
+    expect(filterItem.collectionField).toMatchObject({
+      name: 'name',
+      title: 'Birth place / 省/市/区名称',
+      interface: 'input',
+      type: 'string',
+    });
+    expect(filterItem.collectionField?.filterable?.operators).toBe('string');
+    expect(filterItem.subModels.field).toBeInstanceOf(InputFieldModel);
+  });
+
+  it('uses explicit filterable binding for association fields that provide a filter model', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FilterFormItemModel: FilterFormItemModel as any,
+      DummyCollectionBlockModel,
+      InputFieldModel,
+      TestCascaderFilterFieldModel,
+      FilterFormRecordSelectFieldModel,
+    });
+
+    const ds = engine.dataSourceManager.getDataSource('main');
+    ds?.addCollection({
+      name: 'departments',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } },
+        { name: 'name', type: 'string', interface: 'input', filterable: { operators: [] } },
+      ],
+    });
+    ds?.addCollection({
+      name: 'chinaRegions',
+      fields: [
+        { name: 'code', type: 'string', interface: 'input', filterable: { operators: [] } },
+        { name: 'name', type: 'string', interface: 'input', filterable: { operators: [] } },
+      ],
+    });
+    ds?.addCollection({
+      name: 'students',
+      filterTargetKey: 'id',
+      fields: [
+        {
+          name: 'department',
+          title: 'Department',
+          type: 'belongsTo',
+          interface: 'm2o',
+          target: 'departments',
+          filterable: { operators: [] },
+        },
+        {
+          name: 'birthPlace',
+          title: 'Birth place',
+          type: 'belongsToMany',
+          interface: 'testChinaRegion',
+          target: 'chinaRegions',
+          targetKey: 'code',
+          filterable: { operators: [] },
+        },
+      ],
+    });
+
+    const model = engine.createModel<DummyCollectionBlockModel>({
+      uid: 'students-direct-region-block',
+      use: 'DummyCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'students',
+          },
+        },
+      },
+    });
+
+    const children = (await FilterFormItemModel.defineChildren({
+      blockGridModel: {
+        filterSubModels: (_key: string, predicate: (item: any) => boolean) => [model].filter(predicate),
+      },
+      t: (value: string) => value,
+    } as any)) as any[];
+    const groups = await children[0].children();
+    const fieldsGroup = groups.find((group: any) => group.key === 'fields');
+    const departmentItem = fieldsGroup?.children?.find((item: any) => item.key === 'department');
+    const birthPlaceItem = fieldsGroup?.children?.find((item: any) => item.key === 'birthPlace');
+
+    const departmentCreateOptions = await departmentItem.createModelOptions();
+    const birthPlaceCreateOptions = await birthPlaceItem.createModelOptions();
+
+    expect(departmentCreateOptions.subModels.field.use).toBe('FilterFormRecordSelectFieldModel');
+    expect(birthPlaceCreateOptions.subModels.field.use).toBe('TestCascaderFilterFieldModel');
+    expect(birthPlaceCreateOptions.subModels.field.props).toMatchObject({
+      fieldNames: {
+        label: 'name',
+        value: 'code',
+      },
+      labelInValue: true,
+      multiple: false,
+    });
+
+    const filterItem = engine.createModel({
+      uid: 'filter-item-birth-place-direct',
+      ...birthPlaceCreateOptions,
+    } as any) as unknown as FilterFormItemModel;
+
+    expect(filterItem.fieldPath).toBe('birthPlace');
+    expect(filterItem.subModels.field).toBeInstanceOf(TestCascaderFilterFieldModel);
+  });
+
+  it('uses Cascader by default for tree to-one associations and keeps Dropdown for other associations', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FilterFormItemModel: FilterFormItemModel as any,
+      DummyCollectionBlockModel,
+      CascadeSelectFieldModel,
+      FilterFormRecordSelectFieldModel,
+    });
+
+    const ds = engine.dataSourceManager.getDataSource('main');
+    ds?.addCollection({
+      name: 'organizations',
+      template: 'tree',
+      filterTargetKey: 'id',
+      titleField: 'name',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } },
+        { name: 'name', type: 'string', interface: 'input', filterable: { operators: [] } },
+      ],
+    });
+    ds?.addCollection({
+      name: 'departments',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } },
+        { name: 'name', type: 'string', interface: 'input', filterable: { operators: [] } },
+      ],
+    });
+    ds?.addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        {
+          name: 'organization',
+          title: 'Organization',
+          type: 'belongsTo',
+          interface: 'm2o',
+          target: 'organizations',
+          filterable: { operators: [] },
+        },
+        {
+          name: 'department',
+          title: 'Department',
+          type: 'belongsTo',
+          interface: 'm2o',
+          target: 'departments',
+          filterable: { operators: [] },
+        },
+        {
+          name: 'organizations',
+          title: 'Organizations',
+          type: 'belongsToMany',
+          interface: 'm2m',
+          target: 'organizations',
+          filterable: { operators: [] },
+        },
+      ],
+    });
+
+    const model = engine.createModel<DummyCollectionBlockModel>({
+      uid: 'users-tree-association-block',
+      use: 'DummyCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+          },
+        },
+      },
+    });
+
+    const children = (await FilterFormItemModel.defineChildren({
+      blockGridModel: {
+        filterSubModels: (_key: string, predicate: (item: any) => boolean) => [model].filter(predicate),
+      },
+      t: (value: string) => value,
+    } as any)) as any[];
+    const groups = await children[0].children();
+    const fieldsGroup = groups.find((group: any) => group.key === 'fields');
+    const organizationItem = fieldsGroup?.children?.find((item: any) => item.key === 'organization');
+    const departmentItem = fieldsGroup?.children?.find((item: any) => item.key === 'department');
+    const organizationsItem = fieldsGroup?.children?.find((item: any) => item.key === 'organizations');
+
+    const organizationCreateOptions = await organizationItem.createModelOptions();
+    const departmentCreateOptions = await departmentItem.createModelOptions();
+    const organizationsCreateOptions = await organizationsItem.createModelOptions();
+
+    expect(organizationCreateOptions.subModels.field.use).toBe('CascadeSelectFieldModel');
+    expect(organizationCreateOptions.subModels.field.props).toMatchObject({
+      fieldNames: { label: 'name', value: 'id' },
+    });
+    expect(departmentCreateOptions.subModels.field.use).toBe('FilterFormRecordSelectFieldModel');
+    expect(organizationsCreateOptions.subModels.field.use).toBe('FilterFormRecordSelectFieldModel');
+
+    const filterItem = engine.createModel<FilterFormItemModel>({
+      uid: 'filter-item-tree-organization',
+      ...organizationCreateOptions,
+    });
+    const modelStep = filterItem.getFlow('filterFormItemSettings')?.steps?.model as any;
+    const settingsContext = {
+      engine,
+      collectionField: ds?.getCollection('users')?.getField('organization'),
+      t: (value: string) => engine.translate(value),
+    };
+    const options = modelStep.uiMode(settingsContext).props.options;
+
+    expect(modelStep.hideInSettings(settingsContext)).not.toBe(true);
+    expect(options).toEqual(
+      expect.arrayContaining([
+        { label: 'Dropdown select', value: 'FilterFormRecordSelectFieldModel' },
+        { label: 'Cascader', value: 'CascadeSelectFieldModel' },
+      ]),
+    );
+  });
+
   it('provides fallback field metadata for sql fields without collection context', async () => {
     const engine = new FlowEngine();
     engine.registerModels({

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

@@ -9,6 +9,8 @@
 
 import { describe, expect, it, vi } from 'vitest';
 import '../../../../index';
+import { FlowEngine } from '@nocobase/flow-engine';
+import { CascadeSelectFieldModel } from '../../../fields/AssociationFieldModel/CascadeSelectFieldModel';
 import { FilterFormItemModel } from '../FilterFormItemModel';
 
 describe('FilterFormItemModel getFilterValue', () => {
@@ -174,4 +176,74 @@ describe('FilterFormItemModel getFilterValue', () => {
     const value = FilterFormItemModel.prototype.getFilterValue.call(model as any);
     expect(value).toBe(25);
   });
+
+  it('uses the tree Cascader leaf target key with the equality operator', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ CascadeSelectFieldModel });
+
+    const ds = engine.dataSourceManager.getDataSource('main');
+    ds?.addCollection({
+      name: 'organizations',
+      template: 'tree',
+      filterTargetKey: 'code',
+      fields: [
+        { name: 'code', type: 'string', interface: 'input', filterable: { operators: [] } },
+        { name: 'name', type: 'string', interface: 'input', filterable: { operators: [] } },
+      ],
+    });
+    ds?.addCollection({
+      name: 'users',
+      fields: [
+        {
+          name: 'organization',
+          type: 'belongsTo',
+          interface: 'm2o',
+          target: 'organizations',
+          targetKey: 'code',
+          filterable: { operators: [] },
+        },
+      ],
+    });
+
+    const fieldModel = engine.createModel<CascadeSelectFieldModel>({
+      uid: 'tree-cascader-filter-field',
+      use: 'CascadeSelectFieldModel',
+      stepParams: {
+        fieldSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+            fieldPath: 'organization',
+          },
+        },
+      },
+      props: {
+        fieldNames: { label: 'name', value: 'code' },
+        value: {
+          code: 'leaf',
+          name: 'Leaf organization',
+          parent: { code: 'root', name: 'Root organization', parent: null },
+        },
+      },
+    });
+    const model = {
+      mounted: true,
+      props: { name: 'organization' },
+      subModels: { field: fieldModel },
+      context: {
+        form: {
+          getFieldValue: vi.fn(() => fieldModel.props.value),
+        },
+      },
+      getDefaultValue: vi.fn(() => undefined),
+      getStepParams: vi.fn(() => undefined),
+      getCurrentOperatorMeta: vi.fn(() => null),
+      normalizeAssociationFilterValue: FilterFormItemModel.prototype.normalizeAssociationFilterValue,
+    };
+
+    const value = FilterFormItemModel.prototype.getFilterValue.call(model as unknown as FilterFormItemModel);
+
+    expect(fieldModel.operator).toBe('$eq');
+    expect(value).toBe('leaf');
+  });
 });

package/src/flow/models/blocks/filter-form/__tests__/FilterFormSubmitActionModel.lifecycle.test.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { define, observable } from '@formily/reactive';
+import { describe, expect, it } from 'vitest';
+import { FilterFormSubmitActionModel } from '../FilterFormSubmitActionModel';
+
+describe('FilterFormSubmitActionModel lifecycle', () => {
+  const createAction = (blockModel: { autoTriggerFilter: boolean }, hidden = false, lifecycleAction?: object) => {
+    const action = Object.create(FilterFormSubmitActionModel.prototype) as FilterFormSubmitActionModel;
+
+    Object.defineProperty(action, 'props', {
+      value: {},
+    });
+    Object.defineProperty(action, 'context', {
+      value: { blockModel, model: lifecycleAction || action, defineProperty: () => undefined },
+    });
+    action.hidden = hidden;
+    define(action, {
+      hidden: observable,
+    });
+    action.onInit({});
+
+    return action;
+  };
+
+  it('keeps automatic filtering disabled when the submit action remounts', () => {
+    const blockModel = { autoTriggerFilter: true };
+    const action = createAction(blockModel);
+
+    action.onMount();
+    expect(blockModel.autoTriggerFilter).toBe(false);
+
+    action.onUnmount();
+    expect(blockModel.autoTriggerFilter).toBe(true);
+
+    action.onMount();
+    expect(blockModel.autoTriggerFilter).toBe(false);
+  });
+
+  it('keeps automatic filtering disabled until every mounted submit action unmounts', () => {
+    const blockModel = { autoTriggerFilter: true };
+    const firstAction = createAction(blockModel);
+    const secondAction = createAction(blockModel);
+
+    firstAction.onMount();
+    secondAction.onMount();
+    firstAction.onUnmount();
+    expect(blockModel.autoTriggerFilter).toBe(false);
+
+    secondAction.onUnmount();
+    expect(blockModel.autoTriggerFilter).toBe(true);
+  });
+
+  it('only disables automatic filtering while a visible submit action is mounted', () => {
+    const blockModel = { autoTriggerFilter: true };
+    const action = createAction(blockModel, true);
+
+    action.onMount();
+    expect(blockModel.autoTriggerFilter).toBe(true);
+
+    action.hidden = false;
+    expect(blockModel.autoTriggerFilter).toBe(false);
+
+    action.hidden = true;
+    expect(blockModel.autoTriggerFilter).toBe(true);
+  });
+
+  it('tracks fork lifecycles independently when submit actions share the same uid', () => {
+    const blockModel = { autoTriggerFilter: true };
+    const firstFork = {};
+    const secondFork = {};
+    const firstAction = createAction(blockModel, false, firstFork);
+    const secondAction = createAction(blockModel, false, secondFork);
+
+    firstAction.onMount();
+    secondAction.onMount();
+    firstAction.onUnmount();
+    expect(blockModel.autoTriggerFilter).toBe(false);
+
+    secondAction.onUnmount();
+    expect(blockModel.autoTriggerFilter).toBe(true);
+  });
+});

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

@@ -569,6 +569,9 @@ export class FilterManager {
 
         const blockModel = targetModel as CollectionBlockModel;
         const resource = (targetModel as any).resource;
+        const filterResettableTarget = targetModel as CollectionBlockModel & {
+          resetAfterFilterChange?: () => void;
+        };
 
         // 4.4 检查数据加载模式
         const loadingMode = blockModel.getDataLoadingMode();
@@ -581,6 +584,7 @@ export class FilterManager {
             resource.setPage(1);
           }
           resource.loading = false;
+          filterResettableTarget.resetAfterFilterChange?.();
           return;
         }
 
@@ -590,6 +594,7 @@ export class FilterManager {
           resource.setPage(1); // 重置到第一页
         }
         await resource.refresh();
+        filterResettableTarget.resetAfterFilterChange?.();
       } catch (error) {
         console.error(`Failed to refresh target model "${targetId}": ${error.message}`);
         return;

package/src/flow/models/blocks/filter-manager/__tests__/FilterManager.test.ts

@@ -615,6 +615,46 @@ describe('FilterManager', () => {
       expect(mockTargetModel2.resource.refresh).toHaveBeenCalledTimes(1);
     });
 
+    it('should reset target interaction state after refreshing filtered data', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter-1',
+          targetId: 'target-1',
+          filterPaths: ['name'],
+          operator: '$eq',
+        },
+      ];
+
+      const refresh = vi.fn().mockResolvedValue(undefined);
+      const resetAfterFilterChange = vi.fn(() => {
+        expect(refresh).toHaveBeenCalledTimes(1);
+      });
+      const mockTargetModel = {
+        resource: {
+          addFilterGroup: vi.fn(),
+          removeFilterGroup: vi.fn(),
+          refresh,
+        },
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+        resetAfterFilterChange,
+      };
+      const mockFilterModel = {
+        getFilterValue: vi.fn().mockReturnValue('test-value'),
+      };
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'target-1') return mockTargetModel;
+        if (uid === 'filter-1') return mockFilterModel;
+        return null;
+      });
+
+      await filterManager.refreshTargetsByFilter('filter-1');
+
+      expect(resetAfterFilterChange).toHaveBeenCalledTimes(1);
+      expect(refresh).toHaveBeenCalledTimes(1);
+    });
+
     it('should wait for target resource idle before refreshing', async () => {
       vi.useFakeTimers();
       (filterManager as any).filterConfigs = [

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

@@ -72,17 +72,64 @@ const flowKeepMobileHorizontalClassName = css`
 function isGridDelegatedStep(flowKey: string, stepKey: string): boolean {
   return !!GRID_DELEGATED_STEP_KEYS[flowKey]?.has(stepKey);
 }
+
+interface FormModelWithAvailableData {
+  hasAvailableData(): boolean;
+}
+
+interface FormModelWithSubmit {
+  submit(): Promise<unknown>;
+}
+
+function hasAvailableDataCapability(model: object): model is FormModelWithAvailableData {
+  return 'hasAvailableData' in model && typeof model.hasAvailableData === 'function';
+}
+
+function hasSubmitCapability(model: object): model is FormModelWithSubmit {
+  return 'submit' in model && typeof model.submit === 'function';
+}
+
 export class FormBlockModel<
   T extends DefaultCollectionBlockModelStructure = DefaultCollectionBlockModelStructure,
 > extends CollectionBlockModel<T> {
   formValueRuntime?: FormValueRuntime;
 
+  serialize() {
+    return { ...super.serialize(), variableContractType: { type: 'form', use: this.use } };
+  }
+
   private userModifiedTopLevelFields = new Set<string>();
 
   get form() {
     return this.context.form as FormInstance;
   }
 
+  submitFromRunJs() {
+    if (hasAvailableDataCapability(this) && !this.hasAvailableData()) {
+      return;
+    }
+
+    const submitAction = this.mapSubModels('actions', (action) => action).find((action) =>
+      action.getFlow('submitSettings'),
+    );
+    if (submitAction) {
+      return submitAction.onClick(undefined);
+    }
+
+    const isCoreForm = ['CreateFormModel', 'EditFormModel'].some((modelName) => {
+      const ModelClass = this.flowEngine.getModelClass(modelName);
+      return ModelClass && this instanceof ModelClass;
+    });
+    if (this.context.publicFormRuntime || !isCoreForm || !hasSubmitCapability(this)) {
+      return;
+    }
+
+    this.submit().catch((error: unknown) => {
+      this.context.message.error(this.context.t('Save failed'));
+      console.error('Form submission error:', error);
+    });
+  }
+
   _defaultCustomModelClasses = {
     FormActionGroupModel: 'FormActionGroupModel',
     FormItemModel: 'FormItemModel',