@nocobase/client-v2 2.1.0-beta.29 → 2.1.0-beta.32

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/FormBlockModel.tsx

@@ -699,11 +699,14 @@ FormBlockModel.registerFlow({
     linkageRules: {
       use: 'fieldLinkageRules',
       afterParamsSave(ctx) {
-        // 保存后，自动运行一次
-        ctx.model.applyFlow('eventSettings', {
-          changedValues: {},
-          allValues: ctx.form?.getFieldsValue(true),
-        });
+        // FlowSettings 保存后还会触发一次 beforeRender/rerender，
+        // 这里延迟到该刷新之后再重放联动规则，避免字段组件被 beforeRender 恢复为原始属性。
+        setTimeout(() => {
+          ctx.model.applyFlow('eventSettings', {
+            changedValues: {},
+            allValues: ctx.form?.getFieldsValue(true),
+          });
+        }, 0);
       },
     },
   },

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

@@ -14,6 +14,11 @@ import { FlowEngine, FlowModel, SingleRecordResource } from '@nocobase/flow-engi
 // 直接从 models 聚合导入，避免局部文件相互引用顺序导致的循环依赖
 import { FormBlockContent, FormBlockModel, FormComponent } from '../../../..';
 import { Form } from 'antd';
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
 // -----------------------------
 // Helpers
 // -----------------------------
@@ -319,6 +324,31 @@ describe('FormBlockModel (form/formValues injection & server resolve anchors)',
     expect(flows.has('eventSettings')).toBe(true);
   });
 
+  it('replays linkage rules after the settings rerender tick', async () => {
+    vi.useFakeTimers();
+    const engine = new FlowEngine();
+    const TestFormModel = await createTestFormModelSubclass();
+    const model = new TestFormModel({ uid: 'form-linkage-save', flowEngine: engine } as any);
+    const applyFlow = vi.spyOn(model, 'applyFlow').mockResolvedValue(undefined as any);
+    const flow = model.getFlow('eventSettings') as any;
+    const afterParamsSave = flow?.steps?.linkageRules?.afterParamsSave;
+    const ctx: any = {
+      model,
+      form: {
+        getFieldsValue: vi.fn(() => ({ status: 'draft' })),
+      },
+    };
+
+    afterParamsSave(ctx);
+
+    expect(applyFlow).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(applyFlow).toHaveBeenCalledWith('eventSettings', {
+      changedValues: {},
+      allValues: { status: 'draft' },
+    });
+  });
+
   it('delegates layout/assignRules/linkageRules stepParams to grid model', async () => {
     const model = await setupFormModel();
     const engine = model.flowEngine as FlowEngine;

package/src/flow/models/blocks/form/value-runtime/rules.ts

@@ -1508,16 +1508,21 @@ export class RuleEngine {
   private getRowTargetKey(baseCtx: any, rowPath: NamePath): string | string[] {
     let collection = this.getRootCollection() || this.getCollectionFromContext(baseCtx);
     let field: any;
+    let lastAssociationField: any;
     for (const seg of rowPath) {
       if (typeof seg === 'number') continue;
       if (typeof seg !== 'string' || !seg || !collection?.getField) break;
 
       field = collection?.getField?.(seg);
       if (!field?.isAssociationField?.()) break;
+      lastAssociationField = field;
       collection = field?.targetCollection;
     }
 
-    const raw = field?.targetCollection?.filterTargetKey ?? field?.targetCollection?.filterByTk ?? field?.targetKey;
+    const raw =
+      lastAssociationField?.targetCollection?.filterTargetKey ??
+      lastAssociationField?.targetCollection?.filterByTk ??
+      lastAssociationField?.targetKey;
     if (Array.isArray(raw)) {
       const keys = raw.filter((key): key is string => typeof key === 'string' && !!key);
       return keys.length ? keys : 'id';

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -394,16 +394,21 @@ export class FormValueRuntime {
   private getArrayItemTargetKey(arrayPath?: NamePath): string | string[] {
     let collection = this.model?.context?.collection;
     let field: any;
+    let lastAssociationField: any;
     for (const seg of arrayPath || []) {
       if (typeof seg === 'number') continue;
       if (typeof seg !== 'string' || !collection?.getField) break;
 
       field = collection?.getField?.(seg);
       if (!field?.isAssociationField?.()) break;
+      lastAssociationField = field;
       collection = field?.targetCollection;
     }
 
-    const raw = field?.targetCollection?.filterTargetKey ?? field?.targetCollection?.filterByTk ?? field?.targetKey;
+    const raw =
+      lastAssociationField?.targetCollection?.filterTargetKey ??
+      lastAssociationField?.targetCollection?.filterByTk ??
+      lastAssociationField?.targetKey;
     if (Array.isArray(raw)) {
       const keys = raw.filter((key): key is string => typeof key === 'string' && !!key);
       return keys.length ? keys : 'id';

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -932,12 +932,12 @@ const HighPerformanceTable = React.memo(
 
         return {
           onClick: async (event) => {
-            if (highlightedRowKey !== rowKey) {
-              defineClickedRowRecordVariable(model, record);
-              await model.dispatchEvent('rowClick', { record, rowIndex, event });
+            const selected = highlightedRowKey !== rowKey;
+            defineClickedRowRecordVariable(model, selected ? record : null);
+            try {
+              await model.dispatchEvent('rowClick', { record, rowIndex, event, selected });
+            } finally {
               removeClickedRowRecordVariable(model);
-            } else {
-              await model.dispatchEvent('rowClick', { record, rowIndex, event });
             }
           },
           rowIndex,
@@ -1072,7 +1072,12 @@ TableBlockModel.registerEvents({
 
       const model = ctx.model as TableBlockModel;
       const rowKey = getRowKey(ctx.inputArgs.record, model.collection.filterTargetKey);
-      if (model.props.highlightedRowKey !== rowKey) {
+      const selected = ctx.inputArgs.selected;
+      if (selected === true) {
+        model.highlightRow(ctx.inputArgs.record);
+      } else if (selected === false) {
+        model.clearHighlight();
+      } else if (model.props.highlightedRowKey !== rowKey) {
         model.highlightRow(ctx.inputArgs.record);
       } else {
         model.clearHighlight();

package/src/flow/models/blocks/table/TableColumnModel.tsx

@@ -535,6 +535,9 @@ TableColumnModel.registerFlow({
           fieldModel.setStepParams('fieldSettings', 'init', fieldSettingsInit);
           await fieldModel.dispatchEvent('beforeRender', undefined, { useCache: false });
         }
+        if (targetUse) {
+          ctx.model.setStepParams('tableColumnSettings', 'model', { use: targetUse });
+        }
         ctx.model.setProps(targetCollectionField.getComponentProps());
       },
       defaultParams: (ctx: any) => {

package/src/flow/models/blocks/table/TableSelectModel.tsx

@@ -12,45 +12,55 @@ import { castArray } from 'lodash';
 import { BlockSceneEnum } from '../../base/BlockModel';
 import { TableBlockModel } from './TableBlockModel';
 
+export function getAssociationSelectForeignKeyFilter(collectionField: any) {
+  const isOToAny = ['oho', 'o2m'].includes(collectionField?.interface);
+  const foreignKey = collectionField?.foreignKey;
+  if (!isOToAny || !foreignKey) {
+    return null;
+  }
+  return {
+    [foreignKey]: {
+      $is: null,
+    },
+  };
+}
+
+export function getAssociationSelectAssociatedRecordsFilter(collection: any, associatedRecords: any[] = []) {
+  const targetKey = collection?.filterTargetKey || 'id';
+  const filterKeys = associatedRecords
+    .map((record) => record?.[targetKey])
+    .filter((value) => value !== undefined && value !== null && value !== '');
+
+  if (!filterKeys.length) {
+    return null;
+  }
+
+  return {
+    [`${targetKey}.$ne`]: filterKeys,
+  };
+}
+
 export class TableSelectModel extends TableBlockModel {
   static scene = BlockSceneEnum.select;
   rowSelectionProps: any = observable.deep({});
   onInit(options: any) {
     super.onInit(options);
     const collectionField = this.context.view.inputArgs.collectionField || {};
-    const isOToAny = ['oho', 'o2m'].includes(collectionField?.interface);
-    const sourceId = this.context.view.inputArgs.sourceId;
-    if (isOToAny) {
-      const foreignKey = collectionField.foreignKey;
+    const foreignKeyFilter = getAssociationSelectForeignKeyFilter(collectionField);
+    if (foreignKeyFilter) {
       const filterGroupKey = `${this.uid}-${collectionField.name}`;
-      if (foreignKey) {
-        if (sourceId != null) {
-          this.resource.addFilterGroup(filterGroupKey, {
-            $or: [{ [foreignKey]: { $is: null } }, { [foreignKey]: { $eq: sourceId } }],
-          });
-        } else {
-          this.resource.addFilterGroup(filterGroupKey, {
-            [foreignKey]: {
-              $is: null,
-            },
-          });
-        }
-      }
+      this.resource.addFilterGroup(filterGroupKey, foreignKeyFilter);
     }
 
     Object.assign(this.rowSelectionProps, this.context.view.inputArgs.rowSelectionProps || {});
 
     const getSelectedRows = this.rowSelectionProps?.defaultSelectedRows;
     const selectData = typeof getSelectedRows === 'function' ? getSelectedRows() : getSelectedRows;
-    const data = (selectData && castArray(selectData)) || [];
-    const filterKeys = data
-      .map((v) => {
-        return v[this.collection.filterTargetKey];
-      })
-      .filter(Boolean);
-    this.resource.addFilterGroup(`${this.uid}-select`, {
-      [`${this.collection.filterTargetKey}.$ne`]: filterKeys,
-    });
+    const data = [...castArray(selectData || []), ...castArray(this.context.view.inputArgs.associatedRecords || [])];
+    const associatedRecordsFilter = getAssociationSelectAssociatedRecordsFilter(this.collection, data);
+    if (associatedRecordsFilter) {
+      this.resource.addFilterGroup(`${this.uid}-select`, associatedRecordsFilter);
+    }
   }
 }
 

package/src/flow/models/blocks/table/__tests__/TableBlockModel.rowClick.test.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import '@nocobase/client';
+import { TableBlockModel } from '../TableBlockModel';
+
+function createTableModel() {
+  const engine = new FlowEngine();
+  engine.registerModels({ TableBlockModel });
+
+  const ds = engine.dataSourceManager.getDataSource('main');
+  ds.addCollection({
+    name: 'posts',
+    filterTargetKey: 'id',
+    fields: [
+      { name: 'id', type: 'integer', interface: 'number' },
+      { name: 'title', type: 'string', interface: 'input' },
+    ],
+  });
+
+  return engine.createModel<TableBlockModel>({
+    uid: 'posts-table',
+    use: 'TableBlockModel',
+    stepParams: {
+      resourceSettings: {
+        init: {
+          dataSourceKey: 'main',
+          collectionName: 'posts',
+        },
+      },
+    },
+  });
+}
+
+describe('TableBlockModel rowClick event', () => {
+  it('highlights the clicked row when selected is true', async () => {
+    const model = createTableModel();
+    const record = { id: 1, title: 'first post' };
+    const rowClick = model.getEvent('rowClick');
+
+    await rowClick?.handler({ model, inputArgs: { record, selected: true } } as any, {
+      condition: { logic: '$and', items: [] },
+    });
+
+    expect(model.props.highlightedRowKey).toBe(1);
+  });
+
+  it('clears the highlighted row when selected is false', async () => {
+    const model = createTableModel();
+    const record = { id: 1, title: 'first post' };
+    const rowClick = model.getEvent('rowClick');
+
+    model.highlightRow(record);
+
+    await rowClick?.handler({ model, inputArgs: { record, selected: false } } as any, {
+      condition: { logic: '$and', items: [] },
+    });
+
+    expect(model.props.highlightedRowKey).toBeNull();
+  });
+});