@nocobase/client-v2 2.2.0-beta.9 → 2.2.1

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'),
+          ],
         },
       },
     },
@@ -301,6 +313,40 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Manual');
   });
 
+  it('does not reapply a filter form default value after user clears the field', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel([
+      {
+        key: 'username-default',
+        enable: true,
+        targetPath: 'username',
+        mode: 'default',
+        value: 'admin',
+      },
+    ]);
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('admin');
+
+    values.username_user = undefined;
+    (model as any).handleFilterFormValuesChange({ username_user: undefined }, { username_user: undefined });
+
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'formValuesChange',
+        {
+          changedValues: {
+            username_user: undefined,
+          },
+          allValues: {
+            username_user: undefined,
+          },
+        },
+        { debounce: true },
+      );
+    });
+    expect(values.username_user).toBeUndefined();
+  });
+
   it('applies fixed values even when the target filter field already has a value', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [
@@ -320,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;

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

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

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

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

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

@@ -21,6 +21,10 @@ export type DefaultFormGridStructure = {
 };
 
 export class FormGridModel<T extends DefaultFormGridStructure = DefaultFormGridStructure> extends GridModel<T> {
+  serialize() {
+    return { ...super.serialize(), variableContractType: { type: 'formGrid', use: this.use } };
+  }
+
   itemFallback = (<Skeleton.Input block size="small" style={{ marginBottom: '0.5rem' }} />);
   itemSettingsMenuLevel = 2;
   itemFlowSettings = {