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

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

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

@@ -465,11 +465,17 @@ describe('FormBlockModel (form/formValues injection & server resolve anchors)',
 
   it('builds non-empty contextParams for ctx.formValues.* deep association path', async () => {
     const model = await setupFormModel();
+    const sessionPayload = Buffer.from(JSON.stringify({ userId: 1, signInTime: 'form-record-slots' })).toString(
+      'base64url',
+    );
     // 注入 api mock 到引擎上下文，拦截 variables:resolve 的请求
     const api = {
+      auth: { token: `test.${sessionPayload}.sig` },
       request: vi.fn(async (config: any) => {
-        const payload = config?.data?.values || {};
-        const batch = payload.batch || [];
+        const requestValues = config?.data?.values || {};
+        const batch = requestValues.batch || [];
+        expect(batch[0]?.rd).toEqual(expect.any(String));
+        expect(batch[0]?.template).toEqual({ who: '{{ ctx.formValues.assignees.org.name }}' });
         const cp = batch[0]?.contextParams || {};
         const keys = Object.keys(cp).sort();
         // 聚合为单键，不再使用索引键

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();
+  });
+});