@nocobase/client-v2 2.1.0-alpha.34 → 2.1.0-alpha.36

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

@@ -20,8 +20,9 @@ import _, { cloneDeep, debounce, isEqual } from 'lodash';
 import React from 'react';
 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 } from '../filter-manager/utils';
+import { getAllDataModels, getDefaultOperator, isFilterValueEmpty } from '../filter-manager/utils';
 import { FilterFormFieldModel } from './fields';
 import { normalizeFilterValueByOperator } from './valueNormalization';
 
@@ -58,13 +59,11 @@ const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) =>
     return value;
   }
 
-  const fieldNames = fieldModel?.props?.fieldNames || collectionField?.fieldNames || {};
-  const valueKey =
-    fieldNames?.value ||
-    collectionField?.targetKey ||
-    collectionField?.targetCollection?.filterTargetKey ||
-    collectionField?.collection?.filterTargetKey ||
-    'id';
+  const normalizedFieldNames = normalizeAssociationFieldNames(
+    fieldModel?.props?.fieldNames || collectionField?.fieldNames,
+    collectionField?.targetCollection,
+  );
+  const valueKey = normalizedFieldNames.value;
   const pickValue = (item: any) => {
     const target = item && typeof item === 'object' && typeof item?.data !== 'undefined' ? item.data : item;
     if (!target || typeof target !== 'object') {
@@ -89,6 +88,30 @@ const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) =>
   return pickValue(value);
 };
 
+const hasAssociationRecordValue = (value: any) => {
+  const hasRecord = (item: any) => {
+    const target = item && typeof item === 'object' && typeof item?.data !== 'undefined' ? item.data : item;
+    return !!target && typeof target === 'object';
+  };
+
+  return Array.isArray(value) ? value.some(hasRecord) : hasRecord(value);
+};
+
+const isToOneAssociationField = (collectionField: any) => {
+  return (
+    ['belongsTo', 'hasOne'].includes(collectionField?.type) ||
+    ['m2o', 'o2o', 'oho', 'obo', 'updatedBy', 'createdBy'].includes(collectionField?.interface)
+  );
+};
+
+const isMultipleAssociationField = (fieldModel: any, collectionField: any) => {
+  if (fieldModel?.props?.allowMultiple === true || fieldModel?.props?.multiple === true) {
+    return true;
+  }
+
+  return !isToOneAssociationField(collectionField);
+};
+
 const buildVirtualFilterCollectionField = (ctx: FlowModelContext, filterField: any) => {
   if (!filterField) {
     return;
@@ -480,9 +503,21 @@ export class FilterFormItemModel extends FilterableItemModel<{
    */
   getFilterValue() {
     const fieldModel = this.subModels.field as FieldModel & { getFilterValue?: () => any };
-    const fieldValue = fieldModel.getFilterValue
-      ? fieldModel.getFilterValue()
-      : this.context.form?.getFieldValue(this.props.name);
+    const formValue = this.context.form?.getFieldValue(this.props.name);
+    const modelValue = fieldModel.getFilterValue ? fieldModel.getFilterValue() : formValue;
+    const collectionField = (fieldModel as any)?.context?.collectionField;
+    const isAssociationField =
+      typeof collectionField?.isAssociationField === 'function'
+        ? collectionField.isAssociationField()
+        : !!collectionField?.target;
+    const shouldUseFormValue =
+      isAssociationField &&
+      !this.mounted &&
+      !isFilterValueEmpty(formValue) &&
+      hasAssociationRecordValue(formValue) &&
+      !hasAssociationRecordValue(modelValue);
+    const shouldFallbackToFormValue = isFilterValueEmpty(modelValue) && !isFilterValueEmpty(formValue);
+    const fieldValue = shouldUseFormValue || shouldFallbackToFormValue ? formValue : modelValue;
 
     let rawValue = fieldValue;
 
@@ -517,10 +552,15 @@ export class FilterFormItemModel extends FilterableItemModel<{
     if (!isAssociation) {
       return value;
     }
-    const valueKey = collectionField?.targetKey || collectionField?.targetCollection?.filterTargetKey || 'id';
+    const normalizedFieldNames = normalizeAssociationFieldNames(
+      (fieldModel as any)?.props?.fieldNames || collectionField?.fieldNames,
+      collectionField?.targetCollection,
+    );
+    const valueKey = normalizedFieldNames.value;
     if (Array.isArray(value)) {
       if (value.length === 0) return value;
-      return value.map((item) => (item && typeof item === 'object' ? item[valueKey] : item));
+      const normalizedValue = value.map((item) => (item && typeof item === 'object' ? item[valueKey] : item));
+      return isMultipleAssociationField(fieldModel, collectionField) ? normalizedValue : normalizedValue[0];
     }
     if (typeof value === 'object') {
       return (value as any)?.[valueKey];

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

@@ -18,19 +18,21 @@ describe('FilterFormItemModel getFilterValue', () => {
     association = true,
     fieldNames = { label: 'nickname', value: 'id' },
     collectionField = {},
+    fieldProps = {},
   }: {
     defaultValue: any;
     fieldValue?: any;
     association?: boolean;
     fieldNames?: { label: string; value: string };
     collectionField?: Record<string, any>;
+    fieldProps?: Record<string, any>;
   }) => {
     return {
       mounted: false,
       props: { name: 'ownerId' },
       subModels: {
         field: {
-          props: { fieldNames },
+          props: { fieldNames, ...fieldProps },
           context: {
             collectionField: {
               isAssociationField: () => association,
@@ -99,13 +101,71 @@ describe('FilterFormItemModel getFilterValue', () => {
     expect(value).toBe(23);
   });
 
+  it('uses current form value when association field props are not synchronized yet', () => {
+    const model = createModelMock({
+      defaultValue: undefined,
+      fieldValue: [3],
+      fieldNames: { label: 'nickname', value: 'uuid' },
+      collectionField: { type: 'belongsTo', interface: 'm2o' },
+    });
+    model.context.form.getFieldValue.mockReturnValue([{ id: 3, uuid: 'org-3', nickname: 'Org 3' }]);
+
+    const value = FilterFormItemModel.prototype.getFilterValue.call(model as any);
+    expect(value).toBe('org-3');
+  });
+
+  it('keeps to-one association arrays when allowMultiple is enabled', () => {
+    const model = createModelMock({
+      defaultValue: undefined,
+      fieldValue: [
+        { id: 5, nickname: 'Org 5' },
+        { id: 6, nickname: 'Org 6' },
+      ],
+      collectionField: { type: 'belongsTo', interface: 'm2o' },
+      fieldProps: { allowMultiple: true, multiple: true },
+    });
+
+    const value = FilterFormItemModel.prototype.getFilterValue.call(model as any);
+    expect(value).toEqual([5, 6]);
+  });
+
+  it('keeps association arrays for to-many fields', () => {
+    const model = createModelMock({
+      defaultValue: [
+        { id: 3, uuid: 'org-3', nickname: 'Org 3' },
+        { id: 4, uuid: 'org-4', nickname: 'Org 4' },
+      ],
+      fieldValue: undefined,
+      fieldNames: { label: 'nickname', value: 'uuid' },
+      collectionField: { type: 'belongsToMany', interface: 'm2m' },
+    });
+
+    const value = FilterFormItemModel.prototype.getFilterValue.call(model as any);
+    expect(value).toEqual(['org-3', 'org-4']);
+  });
+
+  it('uses target collection filter target key for association default records', () => {
+    const model = createModelMock({
+      defaultValue: { id: 3, uuid: 'org-3', nickname: 'Org 3' },
+      fieldValue: undefined,
+      fieldNames: null as any,
+      collectionField: {
+        targetKey: 'id',
+        targetCollection: { filterTargetKey: 'uuid' },
+      },
+    });
+
+    const value = FilterFormItemModel.prototype.getFilterValue.call(model as any);
+    expect(value).toBe('org-3');
+  });
+
   it('falls back to collection target key when fieldNames value is missing', () => {
     const model = createModelMock({
       defaultValue: { id: 25, nickname: 'User 25' },
       fieldValue: undefined,
-      fieldNames: undefined as any,
+      fieldNames: null as any,
       collectionField: {
-        fieldNames: undefined,
+        fieldNames: null,
         targetKey: 'id',
         targetCollection: { filterTargetKey: 'id' },
       },

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { filterFormDefaultValues } from '../../../../actions/filterFormDefaultValues';
 import { FilterFormBlockModel } from '../FilterFormBlockModel';
 
@@ -16,4 +16,36 @@ describe('filter-form defaultValues wiring', () => {
     expect(filterFormDefaultValues).toBeTruthy();
     expect(FilterFormBlockModel).toBeTruthy();
   });
+
+  it('only excludes targets already handled by their own initial refresh', async () => {
+    const refreshTargets = vi.fn().mockResolvedValue(undefined);
+    const model = {
+      initialRefreshHandledTargetIds: new Set<string>(),
+      form: {},
+      context: {
+        refreshTargets,
+      },
+      prepareInitialFilterValues: vi.fn().mockResolvedValue(true),
+    };
+
+    FilterFormBlockModel.prototype.markInitialTargetRefreshHandled.call(model as any, 'target-1');
+    await (FilterFormBlockModel.prototype as any).applyDefaultsAndInitialFilter.call(model);
+
+    expect(refreshTargets).toHaveBeenCalledWith({ excludeTargetIds: new Set(['target-1']) });
+  });
+
+  it('does not cache initial defaults when form is not ready', async () => {
+    const model = {
+      form: undefined,
+      initialDefaultsPromise: undefined,
+      ensureFilterItemsBeforeRender: vi.fn().mockResolvedValue(undefined),
+      applyFormDefaultValues: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const prepared = await FilterFormBlockModel.prototype.prepareInitialFilterValues.call(model as any);
+
+    expect(prepared).toBe(false);
+    expect(model.initialDefaultsPromise).toBeUndefined();
+    expect(model.applyFormDefaultValues).not.toHaveBeenCalled();
+  });
 });

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

@@ -18,6 +18,7 @@ function createMockFieldModel(options: { uid: string; props?: Record<string, any
   const model: any = {
     uid: options.uid,
     props: { ...(options.props || {}) },
+    _options: { props: { ...(options.props || {}) } },
     stepParams: { ...(options.stepParams || {}) },
     emitter: { emit: vi.fn() },
     setProps(patch: any) {
@@ -97,7 +98,9 @@ describe('filter-form legacyDefaultValueMigration', () => {
     clearLegacyDefaultValuesFromFilterFormModel(filterFormModel);
 
     expect(field1.props.initialValue).toBeUndefined();
+    expect(field1._options.props.initialValue).toBeUndefined();
     expect(field1.props.keep).toBe(true);
+    expect(field1._options.props.keep).toBe(true);
     expect(field1.stepParams.filterFormItemSettings?.initialValue).toBeUndefined();
     expect(field1.stepParams.otherFlow?.s?.x).toBe(1);
 

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

@@ -24,6 +24,10 @@ type FilterConfig = {
   operator?: string;
 };
 
+export type RefreshTargetsByFilterOptions = {
+  excludeTargetIds?: Set<string> | string[];
+};
+
 const ARRAY_FIELD_OPERATORS_TO_SCALAR_OPERATORS: Record<string, string> = {
   $match: '$in',
   $anyOf: '$in',
@@ -78,6 +82,36 @@ function normalizeOperatorForTargetField(operator: string, targetModel: any, fie
   return scalarOperator;
 }
 
+async function waitForResourceIdle(resource: any) {
+  if (!resource?.loading) {
+    return;
+  }
+
+  await new Promise<void>((resolve) => {
+    const check = () => {
+      if (!resource.loading) {
+        resolve();
+        return;
+      }
+      setTimeout(check, 16);
+    };
+
+    check();
+  });
+}
+
+function getErrorMessage(error: unknown) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  try {
+    return String(error);
+  } catch {
+    return 'Unknown error';
+  }
+}
+
 export class FilterManager {
   private filterConfigs: FilterConfig[];
   private readonly gridModel: FlowModel;
@@ -111,6 +145,32 @@ export class FilterManager {
     };
   }
 
+  async prepareFiltersForTarget(targetId: string) {
+    const relatedConfigs = this.filterConfigs.filter((config) => config.targetId === targetId);
+    const preparedBlockModels = new Set<any>();
+
+    await Promise.all(
+      relatedConfigs.map(async (config) => {
+        try {
+          const filterModel: any = this.gridModel.flowEngine.getModel(config.filterId);
+          const blockModel = filterModel?.context?.blockModel;
+          if (!blockModel || typeof blockModel.prepareInitialFilterValues !== 'function') {
+            return;
+          }
+
+          const prepared = await blockModel.prepareInitialFilterValues();
+          if (prepared !== false) {
+            preparedBlockModels.add(blockModel);
+          }
+        } catch (error) {
+          console.error(`Failed to prepare filter defaults for target "${targetId}": ${getErrorMessage(error)}`);
+        }
+      }),
+    );
+
+    return preparedBlockModels;
+  }
+
   async saveConnectFieldsConfig(filterModelUid: string, config: ConnectFieldsConfig) {
     // 1. 把参数 FilterModelUid 和 config 转换成一个 filterConfigs
     const newFilterConfigs: FilterConfig[] = config.targets.map((target) => ({
@@ -459,7 +519,7 @@ export class FilterManager {
    * await filterManager.refreshTargetsByFilter(['filter-1', 'filter-2']);
    * ```
    */
-  async refreshTargetsByFilter(filterId: string | string[]): Promise<void> {
+  async refreshTargetsByFilter(filterId: string | string[], options?: RefreshTargetsByFilterOptions): Promise<void> {
     // 1. 参数验证和标准化
     if (!filterId) {
       console.error('filterId must be provided');
@@ -482,7 +542,10 @@ export class FilterManager {
     }
 
     // 3. 提取所有相关的 targetId 并去重
-    const targetIds = [...new Set(relatedConfigs.map((config) => config.targetId))];
+    const excludeTargetIds = options?.excludeTargetIds ? new Set(options.excludeTargetIds) : undefined;
+    const targetIds = [...new Set(relatedConfigs.map((config) => config.targetId))].filter(
+      (targetId) => !excludeTargetIds?.has(targetId),
+    );
 
     // 4. 并行处理所有目标模型
     const refreshPromises = targetIds.map(async (targetId) => {
@@ -522,6 +585,7 @@ export class FilterManager {
         }
 
         // 4.5 调用 refresh 方法
+        await waitForResourceIdle(resource);
         if (typeof resource.setPage === 'function') {
           resource.setPage(1); // 重置到第一页
         }

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

@@ -243,6 +243,125 @@ describe('FilterManager', () => {
     });
   });
 
+  describe('prepareFiltersForTarget', () => {
+    it('should prepare filter form initial values before target refresh', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter1',
+          targetId: 'target1',
+          filterPaths: ['name'],
+        },
+      ];
+      const prepareInitialFilterValues = vi.fn().mockResolvedValue(undefined);
+      const filterBlockModel = { prepareInitialFilterValues };
+      const filterModel = {
+        context: {
+          blockModel: filterBlockModel,
+        },
+      };
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'filter1') return filterModel;
+        return null;
+      });
+
+      const prepared = await filterManager.prepareFiltersForTarget('target1');
+
+      expect(prepareInitialFilterValues).toHaveBeenCalledTimes(1);
+      expect(prepared.has(filterBlockModel)).toBe(true);
+    });
+
+    it('should skip marking a filter block when initial values are not ready', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter1',
+          targetId: 'target1',
+          filterPaths: ['name'],
+        },
+      ];
+      const filterBlockModel = { prepareInitialFilterValues: vi.fn().mockResolvedValue(false) };
+      const filterModel = {
+        context: {
+          blockModel: filterBlockModel,
+        },
+      };
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'filter1') return filterModel;
+        return null;
+      });
+
+      const prepared = await filterManager.prepareFiltersForTarget('target1');
+
+      expect(prepared.has(filterBlockModel)).toBe(false);
+    });
+
+    it('should continue preparing other filter blocks when one fails', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter1',
+          targetId: 'target1',
+          filterPaths: ['name'],
+        },
+        {
+          filterId: 'filter2',
+          targetId: 'target1',
+          filterPaths: ['title'],
+        },
+      ];
+      const failingBlockModel = { prepareInitialFilterValues: vi.fn().mockRejectedValue(new Error('bad default')) };
+      const preparedBlockModel = { prepareInitialFilterValues: vi.fn().mockResolvedValue(true) };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'filter1') return { context: { blockModel: failingBlockModel } };
+        if (uid === 'filter2') return { context: { blockModel: preparedBlockModel } };
+        return null;
+      });
+
+      const prepared = await filterManager.prepareFiltersForTarget('target1');
+
+      expect(prepared.has(failingBlockModel)).toBe(false);
+      expect(prepared.has(preparedBlockModel)).toBe(true);
+      expect(errorSpy).toHaveBeenCalled();
+      errorSpy.mockRestore();
+    });
+
+    it('should keep error isolation when a filter block rejects a non-error value', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter1',
+          targetId: 'target1',
+          filterPaths: ['name'],
+        },
+        {
+          filterId: 'filter2',
+          targetId: 'target1',
+          filterPaths: ['title'],
+        },
+      ];
+      const failingBlockModel = { prepareInitialFilterValues: vi.fn().mockRejectedValue('bad default') };
+      const preparedBlockModel = { prepareInitialFilterValues: vi.fn().mockResolvedValue(true) };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'filter1') return { context: { blockModel: failingBlockModel } };
+        if (uid === 'filter2') return { context: { blockModel: preparedBlockModel } };
+        return null;
+      });
+
+      try {
+        const prepared = await filterManager.prepareFiltersForTarget('target1');
+
+        expect(prepared.has(failingBlockModel)).toBe(false);
+        expect(prepared.has(preparedBlockModel)).toBe(true);
+        expect(errorSpy).toHaveBeenCalledWith('Failed to prepare filter defaults for target "target1": bad default');
+      } finally {
+        errorSpy.mockRestore();
+      }
+    });
+  });
+
   describe('addFilterConfig', () => {
     it('should add a new filter config successfully', async () => {
       const filterConfig = {
@@ -496,6 +615,157 @@ describe('FilterManager', () => {
       expect(mockTargetModel2.resource.refresh).toHaveBeenCalledTimes(1);
     });
 
+    it('should wait for target resource idle before refreshing', async () => {
+      vi.useFakeTimers();
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter-1',
+          targetId: 'target-1',
+          filterPaths: ['name'],
+          operator: '$eq',
+        },
+      ];
+
+      const resource = {
+        loading: true,
+        addFilterGroup: vi.fn(),
+        removeFilterGroup: vi.fn(),
+        refresh: vi.fn().mockImplementation(() => {
+          expect(resource.loading).toBe(false);
+          return Promise.resolve();
+        }),
+      };
+      const mockTargetModel = {
+        resource,
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+      };
+      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;
+      });
+
+      const refreshPromise = filterManager.refreshTargetsByFilter('filter-1');
+
+      try {
+        await vi.advanceTimersByTimeAsync(16);
+        expect(resource.refresh).not.toHaveBeenCalled();
+
+        resource.loading = false;
+        await vi.advanceTimersByTimeAsync(16);
+        await refreshPromise;
+
+        expect(resource.refresh).toHaveBeenCalledTimes(1);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('should not refresh before a slow target resource becomes idle', async () => {
+      vi.useFakeTimers();
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter-1',
+          targetId: 'target-1',
+          filterPaths: ['name'],
+          operator: '$eq',
+        },
+      ];
+
+      const resource = {
+        loading: true,
+        addFilterGroup: vi.fn(),
+        removeFilterGroup: vi.fn(),
+        refresh: vi.fn().mockResolvedValue(undefined),
+      };
+      const mockTargetModel = {
+        resource,
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+      };
+      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;
+      });
+
+      const refreshPromise = filterManager.refreshTargetsByFilter('filter-1');
+
+      try {
+        await vi.advanceTimersByTimeAsync(2100);
+
+        expect(resource.refresh).not.toHaveBeenCalled();
+
+        resource.loading = false;
+        await vi.advanceTimersByTimeAsync(16);
+        await refreshPromise;
+
+        expect(resource.refresh).toHaveBeenCalledTimes(1);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('should skip excluded target ids when refreshing', async () => {
+      (filterManager as any).filterConfigs = [
+        {
+          filterId: 'filter-1',
+          targetId: 'target-1',
+          filterPaths: ['name'],
+          operator: '$eq',
+        },
+        {
+          filterId: 'filter-1',
+          targetId: 'target-2',
+          filterPaths: ['name'],
+          operator: '$eq',
+        },
+      ];
+
+      const mockTargetModel1 = {
+        resource: {
+          addFilterGroup: vi.fn(),
+          removeFilterGroup: vi.fn(),
+          refresh: vi.fn().mockResolvedValue(undefined),
+        },
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+      };
+      const mockTargetModel2 = {
+        resource: {
+          addFilterGroup: vi.fn(),
+          removeFilterGroup: vi.fn(),
+          refresh: vi.fn().mockResolvedValue(undefined),
+        },
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+      };
+      const mockFilterModel = {
+        getFilterValue: vi.fn().mockReturnValue('test-value'),
+      };
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'target-1') return mockTargetModel1;
+        if (uid === 'target-2') return mockTargetModel2;
+        if (uid === 'filter-1') return mockFilterModel;
+        return null;
+      });
+
+      await filterManager.refreshTargetsByFilter('filter-1', { excludeTargetIds: new Set(['target-1']) });
+
+      expect(mockTargetModel1.resource.refresh).not.toHaveBeenCalled();
+      expect(mockTargetModel2.resource.refresh).toHaveBeenCalledTimes(1);
+    });
+
     it('should normalize array operators when the target field is scalar', async () => {
       const filterConfigs = [
         {

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

@@ -94,8 +94,6 @@ FormSubmitActionModel.registerFlow({
           ctx.model.setProps('loading', true);
           const { submitHandler } = await import('./submitHandler');
           await submitHandler(ctx, params);
-          ctx.message.success(ctx.t('Saved successfully'));
-          ctx.model.setProps('loading', false);
         } catch (error) {
           ctx.model.setProps('loading', false);
           // 显示保存失败提示
@@ -107,12 +105,8 @@ FormSubmitActionModel.registerFlow({
         }
       },
     },
-    refreshAndClose: {
-      async handler(ctx) {
-        if (ctx.view) {
-          ctx.view.close();
-        }
-      },
+    afterSuccess: {
+      use: 'afterSuccess',
     },
   },
 });