@nocobase/client-v2 2.1.37 → 2.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.37",
+  "version": "2.1.39",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.37",
-    "@nocobase/flow-engine": "2.1.37",
-    "@nocobase/sdk": "2.1.37",
-    "@nocobase/shared": "2.1.37",
-    "@nocobase/utils": "2.1.37",
+    "@nocobase/evaluators": "2.1.39",
+    "@nocobase/flow-engine": "2.1.39",
+    "@nocobase/sdk": "2.1.39",
+    "@nocobase/shared": "2.1.39",
+    "@nocobase/utils": "2.1.39",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -48,5 +48,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "a0c3201363ae028058845af0176ee902a9eeb3e1"
+  "gitHead": "ddbf88ac2a5de1ad94ff4779618cdf1b81aae037"
 }

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__/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/blocks/form/value-runtime/__tests__/runtime.test.ts

@@ -445,6 +445,43 @@ describe('FormValueRuntime (default rules)', () => {
 });
 
 describe('FormValueRuntime (form assign rules)', () => {
+  it('uses the form grid as the variable contract owner', async () => {
+    const engineEmitter = new EventEmitter();
+    const formStub = createFormStub({ b: 'licensed' });
+    const onResolveJsonTemplate = vi.fn();
+    const blockModel: any = {
+      uid: 'form-contract-owner',
+      subModels: { grid: { uid: 'form-contract-owner-grid' } },
+      flowEngine: { emitter: engineEmitter },
+      emitter: new EventEmitter(),
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    const blockCtx = createFieldContext(runtime);
+    const resolveJsonTemplate = blockCtx.resolveJsonTemplate.bind(blockCtx);
+    blockCtx.defineMethod('resolveJsonTemplate', async (template: unknown, options?: unknown) => {
+      onResolveJsonTemplate(options);
+      return resolveJsonTemplate(template, options);
+    });
+    blockModel.context = blockCtx;
+    runtime.mount({ sync: true });
+
+    runtime.syncAssignRules([
+      {
+        key: 'license-version',
+        enable: true,
+        targetPath: 'a',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '__B__',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('licensed'));
+    expect(onResolveJsonTemplate).toHaveBeenCalledWith({ contractModelUid: 'form-contract-owner-grid' });
+  });
+
   it('migrates block-level rule to field instance on mount and restores on unmount', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();

package/src/flow/models/blocks/form/value-runtime/rules.ts

@@ -8,7 +8,14 @@
  */
 
 import { isObservable, reaction, toJS } from '@formily/reactive';
-import { FlowContext, FlowModel, isRunJSValue, normalizeRunJSValue, runjsWithSafeGlobals } from '@nocobase/flow-engine';
+import {
+  FlowContext,
+  FlowModel,
+  isRunJSValue,
+  normalizeRunJSValue,
+  runjsWithSafeGlobals,
+  type ResolveJsonTemplateOptions,
+} from '@nocobase/flow-engine';
 import { getValuesByPath } from '@nocobase/shared';
 import _ from 'lodash';
 import { dayjs } from '@nocobase/utils/client';
@@ -49,6 +56,7 @@ type RuntimeRule = {
   getValue: () => any;
   getCondition?: () => any;
   getContext: () => any;
+  getContractModelUid?: () => string | undefined;
 };
 
 type ObservableBinding = {
@@ -94,6 +102,7 @@ type RuntimeItemChain = {
 
 export type RuleEngineOptions = {
   getBlockModelUid: () => string;
+  getAssignRulesModelUid: () => string | undefined;
   getActionName: () => string | undefined;
   getBlockContext: () => any;
   getEngine: () => any;
@@ -217,6 +226,7 @@ export class RuleEngine {
         getValue: () => template?.value,
         getCondition: () => template?.condition,
         getContext: () => this.options.getBlockContext(),
+        getContractModelUid: this.options.getAssignRulesModelUid,
       };
 
       this.rules.set(id, { rule, state: { deps: new Set(), depDisposers: [], runSeq: 0, scheduledAtWriteSeq: 0 } });
@@ -554,6 +564,7 @@ export class RuleEngine {
           getValue: () => template?.value,
           getCondition: () => template?.condition,
           getContext: () => this.options.getBlockContext(),
+          getContractModelUid: this.options.getAssignRulesModelUid,
         };
 
         this.rules.set(id, { rule, state: { deps: new Set(), depDisposers: [], runSeq: 0, scheduledAtWriteSeq: 0 } });
@@ -922,6 +933,7 @@ export class RuleEngine {
           getValue: () => template?.value,
           getCondition: () => template?.condition,
           getContext: () => model?.context,
+          getContractModelUid: this.options.getAssignRulesModelUid,
         };
 
         this.rules.set(id, { rule, state: { deps: new Set(), depDisposers: [], runSeq: 0, scheduledAtWriteSeq: 0 } });
@@ -1671,7 +1683,7 @@ export class RuleEngine {
       }
     }
 
-    const evalCtx = this.createRuleEvaluationContext(baseCtx, collector, targetNamePath);
+    const evalCtx = this.createRuleEvaluationContext(baseCtx, collector, targetNamePath, rule.getContractModelUid?.());
     return { collector, evalCtx, rawValue, isRunJS };
   }
 
@@ -2010,7 +2022,12 @@ export class RuleEngine {
     return canOverwrite;
   }
 
-  private createRuleEvaluationContext(baseCtx: any, collector: DepCollector, targetNamePath: NamePath | null) {
+  private createRuleEvaluationContext(
+    baseCtx: any,
+    collector: DepCollector,
+    targetNamePath: NamePath | null,
+    contractModelUid?: string,
+  ) {
     const trackingFormValues = this.options.createTrackingFormValues(collector);
     const ctx: any = new FlowContext();
     try {
@@ -2030,12 +2047,19 @@ export class RuleEngine {
     }
 
     const delegatedResolveJsonTemplate =
-      typeof ctx.resolveJsonTemplate === 'function' ? ctx.resolveJsonTemplate.bind(ctx) : undefined;
+      typeof ctx.resolveJsonTemplate === 'function'
+        ? (ctx.resolveJsonTemplate.bind(ctx) as (
+            template: unknown,
+            options?: ResolveJsonTemplateOptions,
+          ) => Promise<unknown>)
+        : undefined;
     ctx.defineMethod('resolveJsonTemplate', async (template: unknown) => {
       const tokenStore = this.createLocalTemplateTokenStore();
       const localResolved = this.resolveLocalFormValuesTemplates(baseCtx, template, collector, tokenStore);
       const nextTemplate = localResolved.matched ? localResolved.value : template;
-      const resolved = delegatedResolveJsonTemplate ? await delegatedResolveJsonTemplate(nextTemplate) : nextTemplate;
+      const resolved = delegatedResolveJsonTemplate
+        ? await delegatedResolveJsonTemplate(nextTemplate, contractModelUid ? { contractModelUid } : undefined)
+        : nextTemplate;
       return this.restoreLocalTemplateTokens(resolved, tokenStore);
     });
 

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -81,6 +81,10 @@ export class FormValueRuntime {
 
     this.ruleEngine = new RuleEngine({
       getBlockModelUid: () => String(this.model?.uid),
+      getAssignRulesModelUid: () => {
+        const grid = this.model?.subModels?.grid;
+        return !Array.isArray(grid) && grid?.uid ? String(grid.uid) : undefined;
+      },
       getActionName: () => this.model?.getAclActionName?.() ?? this.model?.context?.actionName,
       getBlockContext: () => this.model?.context,
       getEngine: () => this.model?.context?.engine,