@nocobase/client-v2 2.1.38 → 2.1.40

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

@@ -72,6 +72,23 @@ 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> {
@@ -87,6 +104,32 @@ export class FormBlockModel<
     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/__tests__/runJsFormSubmit.test.ts

@@ -0,0 +1,131 @@
+/**
+ * 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, vi } from 'vitest';
+import { CreateFormModel } from '../CreateFormModel';
+import { EditFormModel } from '../EditFormModel';
+import { FormActionModel } from '../FormActionModel';
+
+function prepareFormModel<T extends CreateFormModel | EditFormModel>(model: T, publicFormRuntime = false) {
+  const engine = new FlowEngine();
+  engine.registerModels({ CreateFormModel, EditFormModel });
+  model.flowEngine = engine;
+  Object.defineProperty(model, 'context', {
+    value: {
+      publicFormRuntime,
+      message: { error: vi.fn() },
+      t: (value: string) => value,
+    },
+  });
+  return model;
+}
+
+function createSubmitAction() {
+  const onClick = vi.fn();
+  const action = {
+    getFlow: vi.fn((key: string) => (key === 'submitSettings' ? {} : undefined)),
+    onClick,
+  } as unknown as FormActionModel;
+  return { action, onClick };
+}
+
+describe('FormBlockModel.submitFromRunJs', () => {
+  it('dispatches the first action with a submitSettings flow', () => {
+    const { action, onClick } = createSubmitAction();
+    const { action: secondAction, onClick: secondOnClick } = createSubmitAction();
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(CreateFormModel.prototype), {
+        mapSubModels: (_key: string, callback: (item: FormActionModel) => FormActionModel) => [
+          callback(action),
+          callback(secondAction),
+        ],
+      }) as CreateFormModel,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(onClick).toHaveBeenCalledWith(undefined);
+    expect(secondOnClick).not.toHaveBeenCalled();
+  });
+
+  it('does not dispatch an edit submit action without an available record', () => {
+    const { action, onClick } = createSubmitAction();
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(EditFormModel.prototype), {
+        hasAvailableData: () => false,
+        mapSubModels: (_key: string, callback: (item: FormActionModel) => FormActionModel) => [callback(action)],
+      }) as EditFormModel,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(onClick).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the core form submit handler when no submit action exists', () => {
+    const submit = vi.fn().mockResolvedValue(undefined);
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(CreateFormModel.prototype), {
+        mapSubModels: vi.fn(() => []),
+        submit,
+      }) as CreateFormModel,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(submit).toHaveBeenCalledOnce();
+  });
+
+  it('falls back to the core edit submit handler when a record exists', () => {
+    const submit = vi.fn().mockResolvedValue(undefined);
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(EditFormModel.prototype), {
+        hasAvailableData: () => true,
+        mapSubModels: vi.fn(() => []),
+        submit,
+      }) as EditFormModel,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(submit).toHaveBeenCalledOnce();
+  });
+
+  it('uses the core fallback for specialized form subclasses', () => {
+    class SpecializedCreateFormModel extends CreateFormModel {}
+
+    const submit = vi.fn().mockResolvedValue(undefined);
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(SpecializedCreateFormModel.prototype), {
+        mapSubModels: vi.fn(() => []),
+        submit,
+      }) as SpecializedCreateFormModel,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(submit).toHaveBeenCalledOnce();
+  });
+
+  it('does not use the core fallback for public forms without a submit action', () => {
+    const submit = vi.fn().mockResolvedValue(undefined);
+    const blockModel = prepareFormModel(
+      Object.assign(Object.create(CreateFormModel.prototype), {
+        mapSubModels: vi.fn(() => []),
+        submit,
+      }) as CreateFormModel,
+      true,
+    );
+
+    blockModel.submitFromRunJs();
+
+    expect(submit).not.toHaveBeenCalled();
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/CascadeSelectFieldModel.tsx

@@ -8,7 +8,13 @@
  */
 
 import { Cascader, Space, Button } from 'antd';
-import { CollectionField, EditableItemModel, tExpr, MultiRecordResource } from '@nocobase/flow-engine';
+import {
+  CollectionField,
+  EditableItemModel,
+  FilterableItemModel,
+  MultiRecordResource,
+  tExpr,
+} from '@nocobase/flow-engine';
 import { DeleteOutlined } from '@ant-design/icons';
 import { css, cx } from '@emotion/css';
 import { debounce, castArray, omit, last, isEqual } from 'lodash';
@@ -31,6 +37,23 @@ function normalizeLabelKeys(labelKeyOrKeys?: string | string[]): string[] {
   return Array.from(new Set(list.filter((item): item is string => !!item && typeof item === 'string')));
 }
 
+function normalizeCascadeFieldKey(key: unknown): string | undefined {
+  if (typeof key === 'string' && key) {
+    return key;
+  }
+  if (Array.isArray(key) && key.length === 1 && typeof key[0] === 'string') {
+    return key[0];
+  }
+  return undefined;
+}
+
+function getDefaultCascadeFieldNames(field: CollectionField) {
+  const targetCollection = field?.targetCollection;
+  const value = normalizeCascadeFieldKey(targetCollection?.filterTargetKey) || 'id';
+  const label = targetCollection?.titleCollectionField?.name || value;
+  return { label, value };
+}
+
 function getRecordDisplayLabel(item: any, labelKeyOrKeys?: string | string[]): string | null {
   if (!isPlainRecord(item)) return null;
   const labelKeys = normalizeLabelKeys(labelKeyOrKeys);
@@ -815,6 +838,15 @@ EditableItemModel.bindModelToInterface('CascadeSelectFieldModel', ['m2o', 'o2o',
   order: 60,
 });
 
+FilterableItemModel.bindModelToInterface('CascadeSelectFieldModel', ['m2o', 'o2o', 'oho', 'obo'], {
+  when: (ctx, field) => field.targetCollection?.template === 'tree',
+  isDefault: true,
+  order: 60,
+  defaultProps: (ctx, field) => ({
+    fieldNames: getDefaultCascadeFieldNames(field),
+  }),
+});
+
 EditableItemModel.bindModelToInterface('CascadeSelectListFieldModel', ['m2m', 'o2m', 'mbm'], {
   when: (ctx, field) => field.targetCollection?.template === 'tree',
   isDefault: true,

package/src/flow/models/fields/mobile-components/MobileLazySelect.tsx

@@ -206,6 +206,11 @@ export function MobileLazySelect(props: Readonly<LazySelectProps>) {
         return;
       }
       const selectedId = vals[0];
+      if (selectedId === undefined) {
+        onChange(undefined as unknown as AssociationOption);
+        handleClose();
+        return;
+      }
       const record = optionMap.get(selectedId);
       if (record) {
         if (valueMode === 'value') {

package/src/flow/models/fields/mobile-components/__tests__/MobileSelect.test.tsx

@@ -307,6 +307,22 @@ describe('MobileLazySelect', () => {
     expect(screen.getByRole('button', { name: 'Cancel' })).toBeInTheDocument();
   });
 
+  it('clears the selected relation record when it is tapped again in single mode', () => {
+    const { onChange } = renderMobileLazySelect({
+      value: RELATION_OPTIONS[0],
+      multiple: false,
+    });
+
+    openLazyPopup();
+    expect(mockState.checklistProps?.value).toEqual([RELATION_OPTIONS[0].uuid]);
+
+    selectValues([]);
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith(undefined);
+    expect(screen.queryByTestId('popup')).not.toBeInTheDocument();
+  });
+
   it('keeps pending relation records selected until confirm', () => {
     const { onChange, rerender } = renderMobileLazySelect();