@nocobase/client-v2 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/flow/models/actions/UpdateRecordActionUtils.ts

@@ -8,9 +8,15 @@
  */
 
 import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import type { AxiosRequestConfig } from 'axios';
 import { dispatchEventDeep } from '../../utils';
 import { resolveAssignFieldValues } from '../blocks/assign-form/assignFieldValuesFlow';
 
+type UpdateRecordActionParams = {
+  assignedValues?: unknown;
+  requestConfig?: AxiosRequestConfig;
+};
+
 export async function refreshLinkageRulesAfterUpdate(ctx: any) {
   const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
   const actionModel = ctx?.model;
@@ -48,11 +54,11 @@ export async function refreshLinkageRulesAfterUpdate(ctx: any) {
 
 export async function applyUpdateRecordAction(
   ctx: any,
-  params: any,
+  params: UpdateRecordActionParams,
   options?: {
     settingsFlowKey?: string;
   },
-) {
+): Promise<boolean> {
   const settingsFlowKey = options?.settingsFlowKey || 'assignSettings';
 
   // 统一接入二次确认：如果启用则弹窗；未配置时默认不启用
@@ -62,25 +68,31 @@ export async function applyUpdateRecordAction(
 
   const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'UpdateRecordAction');
   if (!assignedValues) {
-    return;
+    return false;
   }
 
   if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
     ctx.message.warning(ctx.t('No assigned fields configured'));
-    return;
+    return false;
   }
   const collection = ctx.collection?.name;
   const filterByTk = ctx.collection?.getFilterByTK?.(ctx.record);
   if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) {
     ctx.message.error(ctx.t('Record is required to perform this action'));
-    return;
+    return false;
   }
+  let updated = false;
   if (ctx.resource instanceof SingleRecordResource) {
     await ctx.resource.save(assignedValues, params.requestConfig);
+    updated = true;
   } else if (ctx.resource instanceof MultiRecordResource) {
     await ctx.resource.update(filterByTk, assignedValues, params.requestConfig);
+    updated = true;
+  }
+  if (!updated) {
+    return false;
   }
 
   await refreshLinkageRulesAfterUpdate(ctx);
-  ctx.message.success(ctx.t('Saved successfully'));
+  return true;
 }

package/src/flow/models/actions/__tests__/UpdateRecordActionModel.test.ts

@@ -8,8 +8,9 @@
  */
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { MultiRecordResource } from '@nocobase/flow-engine';
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { applyUpdateRecordAction } from '../UpdateRecordActionUtils';
+import { UpdateRecordActionModel } from '../UpdateRecordActionModel';
 import { dispatchEventDeep } from '../../../utils';
 
 vi.mock('../../../utils', () => ({
@@ -21,7 +22,7 @@ describe('UpdateRecordActionModel apply action', () => {
     vi.clearAllMocks();
   });
 
-  it('dispatches paginationChange for action and block after successful update', async () => {
+  it('dispatches paginationChange and returns success after updating the record', async () => {
     const resource: any = Object.create(MultiRecordResource.prototype);
     resource.update = vi.fn(async () => ({}));
     resource.refresh = vi.fn(async () => {});
@@ -52,12 +53,13 @@ describe('UpdateRecordActionModel apply action', () => {
       t: (value: string) => value,
     };
 
-    await applyUpdateRecordAction(ctx, {
+    const updated = await applyUpdateRecordAction(ctx, {
       assignedValues: {
         marital_status: '已婚',
       },
     });
 
+    expect(updated).toBe(true);
     expect(resource.update).toHaveBeenCalledWith(1, { marital_status: '已婚' }, undefined);
     expect(resource.refresh).not.toHaveBeenCalled();
 
@@ -67,6 +69,76 @@ describe('UpdateRecordActionModel apply action', () => {
     expect(paginationCalls.length).toBeGreaterThan(0);
     expect(paginationCalls.some(([model]: [any]) => model === ctx.model)).toBe(true);
     expect(paginationCalls.some(([model]: [any]) => model === blockModel)).toBe(true);
-    expect(ctx.message.success).toHaveBeenCalledWith('Saved successfully');
+    expect(ctx.message.success).not.toHaveBeenCalled();
+  });
+
+  it('runs the configured after-success action only after a successful update', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action', flowEngine: engine } as any);
+    action.setStepParams('assignSettings', 'confirm', { enable: false });
+    action.setStepParams('assignSettings', 'afterSuccess', {
+      successMessage: 'Record updated',
+    });
+
+    const resource: any = Object.create(MultiRecordResource.prototype);
+    resource.update = vi.fn(async () => ({}));
+    const blockModel: any = { uid: 'details-block' };
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      blockModel,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource,
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: { status: 'active' } });
+
+    expect(runAction).toHaveBeenNthCalledWith(1, 'confirm', { enable: false });
+    expect(runAction).toHaveBeenNthCalledWith(2, 'afterSuccess', {
+      successMessage: 'Record updated',
+      manualClose: false,
+      actionAfterSuccess: 'stay',
+    });
+  });
+
+  it('does not run the after-success action when no fields are assigned', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action-empty', flowEngine: engine } as any);
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource: Object.create(MultiRecordResource.prototype),
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: {} });
+
+    expect(runAction).toHaveBeenCalledTimes(1);
+    expect(runAction).toHaveBeenCalledWith('confirm', { enable: false });
+    expect(ctx.message.warning).toHaveBeenCalledWith('No assigned fields configured');
   });
 });

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -10,23 +10,20 @@
 import React from 'react';
 import { Input } from 'antd';
 import { define, observable } from '@formily/reactive';
-import {
-  FlowModelRenderer,
-  FormItem,
-  VariableInput,
-  tExpr,
-  isVariableExpression,
-  parseValueToPath,
-  isRunJSValue,
-  EditableItemModel,
-  jioToJoiSchema,
-} from '@nocobase/flow-engine';
+import { FlowModelRenderer, FormItem, tExpr, EditableItemModel, jioToJoiSchema } from '@nocobase/flow-engine';
 // 无需类型导入（避免未使用的类型）
 import { FormItemModel } from '../form/FormItemModel';
 import { EditFormModel } from '../form/EditFormModel';
 import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
+import {
+  DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+  FieldValueVariableInput,
+  getFieldInterface,
+  isDateLikeField,
+  resolveDateVariableComponentProps,
+} from '../../../components/field-value-variable';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -285,7 +282,9 @@ export class AssignFormItemModel extends FormItemModel {
         ) : null;
       };
 
-      const NullComponent: React.FC = () => <Input placeholder={'<Null>'} readOnly style={{ width: '100%' }} />;
+      const NullComponent: React.FC = () => (
+        <Input placeholder={`<${this.context.t?.('Null') ?? 'Null'}>`} readOnly style={{ width: '100%' }} />
+      );
 
       const RunJSComponent: React.FC<any> = (inputProps: any) => {
         return (
@@ -298,46 +297,18 @@ export class AssignFormItemModel extends FormItemModel {
         );
       };
 
-      const converters = {
-        renderInputComponent: (meta: any) => {
-          const firstPath = meta?.paths?.[0];
-          if (firstPath === 'constant') return ConstantValueEditor as any;
-          if (firstPath === 'null') return NullComponent as any;
-          if (firstPath === 'runjs') return RunJSComponent as any;
-          return undefined;
-        },
-        resolveValueFromPath: (item: any) => {
-          const firstPath = item?.paths?.[0];
-          if (firstPath === 'constant') return '';
-          if (firstPath === 'null') return null;
-          if (firstPath === 'runjs') return { code: '', version: 'v2' };
-          return undefined;
-        },
-        resolvePathFromValue: (currentValue: any) => {
-          if (currentValue === null) return ['null'];
-          if (isRunJSValue(currentValue)) return ['runjs'];
-          return isVariableExpression(currentValue) ? parseValueToPath(currentValue) : ['constant'];
-        },
-      } as any;
-
-      // 合并变量树：在最前面追加“常量/空值”两个选项
-      const mergedMetaTree = async () => {
+      const baseMetaTree = async () => {
         const getTree = (this.context as any)?.getPropertyMetaTree;
-        const base: any[] = typeof getTree === 'function' ? await getTree() : [];
-        return [
-          {
-            title: tExpr('Constant'),
-            name: 'constant',
-            type: 'string',
-            paths: ['constant'],
-            render: ConstantValueEditor,
-          },
-          { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-          ...base,
-        ];
+        return typeof getTree === 'function' ? await getTree() : [];
       };
 
+      const targetCollectionField = collection?.getField?.(this.fieldPath);
+      const targetFieldInterface = getFieldInterface(targetCollectionField);
+      const dateLike = isDateLikeField(targetCollectionField, this.fieldPath?.split('.').slice(-1)[0]);
+      const dateComponentProps = dateLike
+        ? resolveDateVariableComponentProps(targetCollectionField, targetFieldInterface)
+        : DEFAULT_DATE_VARIABLE_COMPONENT_PROPS;
+
       // 计算 label：优先使用配置中的 label，其次集合字段标题，最后回退字段路径
       let labelText = this.props?.label ?? this.fieldPath ?? '';
       const cf = collection?.getField?.(this.fieldPath);
@@ -357,14 +328,18 @@ export class AssignFormItemModel extends FormItemModel {
             const formValue = formBindingProps?.__assign_value__;
             const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
             return (
-              <VariableInput
+              <FieldValueVariableInput
                 value={mergedValue}
-                onChange={(v: any) => {
+                onChange={(v) => {
                   this.assignValue = v;
                   formBindingProps?.__assign_trigger__?.(v);
                 }}
-                metaTree={mergedMetaTree}
-                converters={converters}
+                baseMetaTree={baseMetaTree}
+                constantComponent={ConstantValueEditor}
+                nullComponent={NullComponent}
+                runJSComponent={RunJSComponent}
+                isDateLikeField={dateLike}
+                dateComponentProps={dateComponentProps}
                 clearValue={''}
               />
             );

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

@@ -77,6 +77,10 @@ export class FormBlockModel<
 > extends CollectionBlockModel<T> {
   formValueRuntime?: FormValueRuntime;
 
+  serialize() {
+    return { ...super.serialize(), variableContractType: { type: 'form', use: this.use } };
+  }
+
   private userModifiedTopLevelFields = new Set<string>();
 
   get form() {

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();
         // 聚合为单键，不再使用索引键