@nocobase/client-v2 2.3.0-alpha.1 → 2.3.0-beta.3

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-form/__tests__/defaultValues.wiring.test.ts

@@ -17,7 +17,15 @@ import { FilterFormBlockModel } from '../FilterFormBlockModel';
 function resolveTemplateValue(raw: any, values: Record<string, any>): any {
   if (typeof raw === 'string') {
     const matched = raw.match(/^\{\{\s*ctx\.formValues\.([^}]+?)\s*\}\}$/);
-    return matched ? values[matched[1]] : raw;
+    if (matched) {
+      return values[matched[1]];
+    }
+
+    if (/^\{\{\s*ctx\.date\.relative\.past\.day\.n7\s*\}\}$/.test(raw)) {
+      return '2026-06-15';
+    }
+
+    return raw;
   }
   if (Array.isArray(raw)) {
     return raw.map((item) => resolveTemplateValue(item, values));
@@ -30,7 +38,7 @@ function resolveTemplateValue(raw: any, values: Record<string, any>): any {
 
 function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<string, any> = {}) {
   const values = { ...initialValues };
-  const createItem = (fieldPath: string, uid: string) => ({
+  const createItem = (fieldPath: string, uid: string, operator?: string) => ({
     uid,
     fieldPath,
     props: { name: `${fieldPath}_${uid}` },
@@ -44,7 +52,7 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
       return undefined;
     },
     subModels: {
-      field: {},
+      field: operator ? { operator } : {},
     },
   });
   const model = {
@@ -76,7 +84,11 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
     subModels: {
       grid: {
         subModels: {
-          items: [createItem('nickname', 'nick'), createItem('username', 'user')],
+          items: [
+            createItem('nickname', 'nick'),
+            createItem('username', 'user'),
+            createItem('birthdate_tz', 'birthdate', '$dateOn'),
+          ],
         },
       },
     },
@@ -354,6 +366,22 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Bob');
   });
 
+  it('preserves relative date descriptors for date filter default values', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel([
+      {
+        key: 'birthdate-default',
+        enable: true,
+        targetPath: 'birthdate_tz',
+        mode: 'assign',
+        value: '{{ ctx.date.relative.past.day.n7 }}',
+      },
+    ]);
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+
+    expect(values.birthdate_tz_birthdate).toEqual({ type: 'past', unit: 'day', number: 7 });
+  });
+
   it('applies override values until the target filter field is changed by user', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [

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;