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

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-form/fields/FieldComponentProps.tsx

@@ -351,7 +351,7 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
       <FormItem label={t('Options')}>
         <Space direction="vertical" size={8} style={{ width: '100%' }}>
           {options.map((option: any, index: number) => (
-            <Space key={`${option.value}-${index}`} style={{ width: '100%' }} size={8} wrap align="start">
+            <Space key={index} style={{ width: '100%' }} size={8} wrap align="start">
               <Input
                 style={{ flex: 1, minWidth: 120 }}
                 placeholder={t('Option label')}

package/src/flow/models/blocks/filter-form/fields/__tests__/FieldComponentProps.options.test.tsx

@@ -0,0 +1,61 @@
+/**
+ * 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 React from 'react';
+import { describe, expect, it } from 'vitest';
+import { createForm } from '@formily/core';
+import { Field, FormProvider } from '@formily/react';
+import { render, screen } from '@nocobase/test/client';
+import userEvent from '@testing-library/user-event';
+import { FlowEngine, FlowEngineProvider, FlowModel, FlowModelProvider } from '@nocobase/flow-engine';
+import { FieldComponentProps } from '../FieldComponentProps';
+
+class HostModel extends FlowModel {
+  render() {
+    return null;
+  }
+}
+
+describe.each(['RadioGroupFieldModel', 'CheckboxGroupFieldModel', 'SelectFieldModel'])('%s options', (fieldModel) => {
+  it('keeps focus while editing option values and preserves remaining rows after removal', async () => {
+    const form = createForm();
+    const engine = new FlowEngine();
+    engine.registerModels({ HostModel });
+    const model = engine.createModel<HostModel>({ use: 'HostModel' });
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowModelProvider model={model}>
+          <FormProvider form={form}>
+            <Field name="props" component={[FieldComponentProps, { fieldModel, source: [] }]} />
+          </FormProvider>
+        </FlowModelProvider>
+      </FlowEngineProvider>,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'plus Add' }));
+    const valueInput = screen.getByPlaceholderText('Option value');
+    await userEvent.type(valueInput, 'abcdef');
+    expect(screen.getByPlaceholderText('Option value')).toHaveValue('abcdef');
+    expect(valueInput).toHaveFocus();
+
+    await userEvent.keyboard('{Backspace}{Backspace}xy');
+    expect(valueInput).toHaveValue('abcdxy');
+    expect(valueInput).toHaveFocus();
+    await userEvent.type(screen.getByPlaceholderText('Option label'), 'First');
+    await userEvent.click(screen.getByRole('button', { name: 'plus Add' }));
+    await userEvent.type(screen.getAllByPlaceholderText('Option label')[1], 'Second');
+    await userEvent.type(screen.getAllByPlaceholderText('Option value')[1], 'second');
+    await userEvent.click(screen.getAllByRole('button', { name: 'close' })[0]);
+    expect(screen.getByPlaceholderText('Option label')).toHaveValue('Second');
+    expect(screen.getByPlaceholderText('Option value')).toHaveValue('second');
+    await userEvent.type(screen.getByPlaceholderText('Option value'), '2');
+    expect(screen.getByPlaceholderText('Option value')).toHaveFocus();
+    expect(form.values.props.options).toEqual([{ label: 'Second', value: 'second2' }]);
+  });
+});

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',
@@ -352,20 +399,41 @@ export class FormBlockModel<
           if (Array.isArray(topValue) && topValue.length === 0) return false;
 
           // 本地优先：支持对多关系的 dot 聚合路径（例如 assignees.name）。
-          // lodash.get 对数组聚合路径会返回 undefined（如 _.get({ assignees:[{name:'A'}] }, 'assignees.name')），
-          // 因而这里先用 getValuesByPath 做一次前端可解析性检查，命中则直接前端解析。
+          // 关联字段只有在本地值包含目标标题字段时才算完整；标量外键或仅含主键的轻量对象仍需服务端补全。
           const formValuesSnapshot = runtime.getFormValuesSnapshot();
+          let shouldResolveAssociationValueOnServer = false;
           if (formValuesSnapshot && typeof formValuesSnapshot === 'object') {
-            const localResolved = getValuesByPath(formValuesSnapshot as Record<string, any>, subPath);
+            const localResolved = getValuesByPath(formValuesSnapshot as Record<string, unknown>, subPath);
             if (typeof localResolved !== 'undefined') {
-              return false;
+              const fieldPath = subPath
+                .replace(/\[\d+\]/g, '')
+                .split('.')
+                .filter((segment) => !/^\d+$/.test(segment))
+                .join('.');
+              const resolvedField = this.collection?.getFieldByPath?.(fieldPath);
+              const titleFieldName = resolvedField?.targetCollectionTitleFieldName;
+              const isLoadedAssociationRecord = (value: unknown) => {
+                if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+                if (!titleFieldName) return true;
+                return typeof (value as Record<string, unknown>)[titleFieldName] !== 'undefined';
+              };
+              const isAssociationValueLoaded =
+                localResolved === null ||
+                (Array.isArray(localResolved)
+                  ? localResolved.length === 0 ||
+                    localResolved.every((value) => value === null || isLoadedAssociationRecord(value))
+                  : isLoadedAssociationRecord(localResolved));
+              if (!resolvedField?.isAssociationField?.() || isAssociationValueLoaded) {
+                return false;
+              }
+              shouldResolveAssociationValueOnServer = true;
             }
           }
 
           // 已配置字段：仅关联字段的子路径按需服务端补全（保持现有语义）
           const assocResolver = createAssociationSubpathResolver(
             () => this.collection,
-            () => runtime.getFormValuesSnapshot(),
+            shouldResolveAssociationValueOnServer ? undefined : () => runtime.getFormValuesSnapshot(),
           );
           return assocResolver(subPath);
         }

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 = {