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

package/src/flow/internal/utils/enumOptionsUtils.ts

@@ -46,6 +46,35 @@ export function enumToOptions(uiEnum: UiSchemaEnumItem[] | undefined, t: (s: str
   return translateOptions(normalized, t);
 }
 
+export function normalizeSelectRenderValue(value: unknown, props?: Record<string, any>) {
+  const mode = props?.mode;
+  const isMultiple = mode === 'multiple' || mode === 'tags' || props?.multiple === true;
+
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== '' && item !== null && typeof item !== 'undefined');
+  }
+
+  if (value === '' || value === null || typeof value === 'undefined') {
+    return isMultiple ? [] : undefined;
+  }
+
+  return value;
+}
+
+export function getSelectedEnumLabels(value: any, fallbackOptions: Option[] = []): Array<{ value: any; label: any }> {
+  const values = Array.isArray(value) ? value : value == null ? [] : [value];
+  return values.map((item) => {
+    const fallback = fallbackOptions.find((option) => option?.value === item);
+    if (fallback) {
+      return { value: item, label: fallback.label };
+    }
+    return {
+      value: item,
+      label: item?.toString?.() ?? item,
+    };
+  });
+}
+
 // Populate model.props.options from uiSchema.enum if missing; returns whether options were injected
 export function ensureOptionsFromUiSchemaEnumIfAbsent(model: FlowModel, collectionField: CollectionField): boolean {
   const iface = collectionField?.interface;

package/src/flow/models/actions/AssociateActionModel.tsx

@@ -16,6 +16,7 @@ import { SkeletonFallback } from '../../components/SkeletonFallback';
 import { ActionModel, ActionSceneEnum } from '../base';
 import {
   applyAssociateAction,
+  getAssociationSelectorContextInputArgs,
   getAssociationTargetResourceSettings,
   isAssociationBlockContext,
 } from './AssociationActionUtils';
@@ -139,7 +140,6 @@ AssociateActionModel.registerFlow({
   steps: {
     openSelector: {
       async handler(ctx, params) {
-        const blockModel = ctx.blockModel;
         const targetResourceSettings = getAssociationTargetResourceSettings(ctx);
         const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params?.mode || 'drawer';
         const size = ctx.inputArgs?.size || params?.size || 'medium';
@@ -168,9 +168,9 @@ AssociateActionModel.registerFlow({
             scene: 'select',
             dataSourceKey: targetResourceSettings.dataSourceKey,
             collectionName: targetResourceSettings.collectionName,
+            ...getAssociationSelectorContextInputArgs(ctx),
             rowSelectionProps: {
               type: 'checkbox',
-              defaultSelectedRows: () => blockModel?.resource?.getData?.() || [],
               renderCell: undefined,
               selectedRowKeys: undefined,
               onChange: (_, selectedRows) => {

package/src/flow/models/actions/AssociationActionUtils.ts

@@ -33,6 +33,20 @@ export const getAssociationTargetResourceSettings = (ctx: FlowModelContext | any
   };
 };
 
+export const getAssociationSelectorContextInputArgs = (ctx: FlowModelContext | any) => {
+  const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel;
+  const association = blockModel?.association;
+  const resourceSettings = getAssociationBlockResourceSettings(ctx);
+  const sourceId = blockModel?.resource?.getSourceId?.() ?? resourceSettings?.sourceId;
+  const associatedRecords = blockModel?.resource?.getData?.() || [];
+
+  return {
+    collectionField: association,
+    sourceId,
+    associatedRecords,
+  };
+};
+
 const callAssociationResourceAction = async (resource: any, action: 'add' | 'remove', values: any[]) => {
   if (typeof resource?.[action] === 'function') {
     return await resource[action]({ values });

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

@@ -16,6 +16,7 @@ import {
   AssociateActionModel,
   CollectionActionGroupModel,
   DisassociateActionModel,
+  getAssociationSelectorContextInputArgs,
   getAssociationTargetResourceSettings,
   PopupActionModel,
   RecordActionGroupModel,
@@ -87,6 +88,68 @@ describe('association action models', () => {
     });
   });
 
+  it('passes one-to-many association context to selector table blocks', () => {
+    const association = {
+      name: 'orders',
+      interface: 'o2m',
+      target: 'orders',
+      sourceKey: 'id',
+      foreignKey: 'userId',
+    };
+    const ctx: any = {
+      blockModel: {
+        association,
+        resource: {
+          getSourceId: () => 362872646860800,
+        },
+        getResourceSettingsInitParams: () => ({
+          dataSourceKey: 'main',
+          collectionName: 'orders',
+          associationName: 'users.orders',
+          sourceId: '{{ctx.popup.record.id}}',
+        }),
+      },
+    };
+
+    expect(getAssociationSelectorContextInputArgs(ctx)).toEqual({
+      collectionField: association,
+      sourceId: 362872646860800,
+      associatedRecords: [],
+    });
+  });
+
+  it('passes current associated records to selector table blocks', () => {
+    const associatedRecords = [{ id: 11 }, { id: 12 }];
+    const association = {
+      name: 'tags',
+      interface: 'm2m',
+      target: 'tags',
+      sourceKey: 'id',
+      targetKey: 'id',
+    };
+    const ctx: any = {
+      blockModel: {
+        association,
+        resource: {
+          getSourceId: () => 1,
+          getData: () => associatedRecords,
+        },
+        getResourceSettingsInitParams: () => ({
+          dataSourceKey: 'main',
+          collectionName: 'tags',
+          associationName: 'posts.tags',
+          sourceId: '{{ctx.popup.record.id}}',
+        }),
+      },
+    };
+
+    expect(getAssociationSelectorContextInputArgs(ctx)).toEqual({
+      collectionField: association,
+      sourceId: 1,
+      associatedRecords,
+    });
+  });
+
   it('shows Associate only in collection actions of association blocks', async () => {
     const engine = createEngine();
 

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

@@ -662,6 +662,9 @@ CollectionBlockModel.registerFlow({
       async handler(ctx) {
         const blockModel = ctx.model as CollectionBlockModel;
         const filterManager: FilterManager = ctx.model.context.filterManager;
+        const preparedFilterBlocks = filterManager?.prepareFiltersForTarget
+          ? await filterManager.prepareFiltersForTarget(ctx.model.uid)
+          : undefined;
         if (filterManager) {
           filterManager.bindToTarget(ctx.model.uid);
         }
@@ -679,6 +682,10 @@ CollectionBlockModel.registerFlow({
           return;
         }
 
+        preparedFilterBlocks?.forEach((filterBlockModel: any) => {
+          filterBlockModel?.markInitialTargetRefreshHandled?.(ctx.model.uid);
+        });
+
         if (ctx.model.isManualRefresh) {
           ctx.model.resource.loading = false;
         } else {

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

@@ -32,7 +32,7 @@ import { BlockSceneEnum } from '../../base/BlockModel';
 import { FilterBlockModel } from '../../base/FilterBlockModel';
 import { FormComponent } from '../form/FormBlockModel';
 import { isEmptyValue } from '../form/value-runtime/utils';
-import { FilterManager } from '../filter-manager/FilterManager';
+import { FilterManager, type RefreshTargetsByFilterOptions } from '../filter-manager/FilterManager';
 import { FilterFormItemModel } from './FilterFormItemModel';
 import { clearLegacyDefaultValuesFromFilterFormModel } from './legacyDefaultValueMigration';
 import { findFormItemModelByFieldPath } from '../../../internal/utils/modelUtils';
@@ -54,6 +54,8 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   autoTriggerFilter = true;
 
   private removeTargetBlockListener?: () => void;
+  private initialDefaultsPromise?: Promise<void>;
+  private initialRefreshHandledTargetIds = new Set<string>();
 
   get form() {
     return this.context.form;
@@ -82,13 +84,13 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     this.context.defineProperty('blockModel', {
       value: this,
     });
-    this.context.defineMethod('refreshTargets', async () => {
+    this.context.defineMethod('refreshTargets', async (options?: RefreshTargetsByFilterOptions) => {
       const gridModel = this.subModels.grid;
       const fieldModels: FilterFormItemModel[] = gridModel.subModels.items;
-      if (fieldModels) {
-        fieldModels.forEach((fieldModel) => {
-          fieldModel?.doFilter?.();
-        });
+      const filterIds = fieldModels?.map((fieldModel) => fieldModel?.uid).filter(Boolean);
+      if (filterIds?.length) {
+        const filterManager: FilterManager = this.context.filterManager;
+        await filterManager.refreshTargetsByFilter(filterIds, options);
       }
     });
   }
@@ -124,9 +126,31 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   }
 
   private async applyDefaultsAndInitialFilter() {
-    await this.ensureFilterItemsBeforeRender();
-    await this.applyFormDefaultValues();
-    await this.context.refreshTargets?.();
+    const prepared = await this.prepareInitialFilterValues();
+    if (prepared) {
+      await this.context.refreshTargets?.({ excludeTargetIds: this.initialRefreshHandledTargetIds });
+    }
+  }
+
+  async prepareInitialFilterValues() {
+    if (!this.form) {
+      return false;
+    }
+
+    if (!this.initialDefaultsPromise) {
+      this.initialDefaultsPromise = (async () => {
+        await this.ensureFilterItemsBeforeRender();
+        await this.applyFormDefaultValues();
+      })();
+    }
+
+    await this.initialDefaultsPromise;
+    return true;
+  }
+
+  markInitialTargetRefreshHandled(targetId: string) {
+    if (!targetId) return;
+    this.initialRefreshHandledTargetIds.add(targetId);
   }
 
   private async ensureFilterItemsBeforeRender() {

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-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); // 重置到第一页
         }