@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.46

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -27,6 +27,7 @@ import _ from 'lodash';
 import { NumberPicker } from '@formily/antd-v5';
 import { enumToOptions, normalizeSelectRenderValue, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
 import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
+import { limitAssociationMetaTree } from './metaTreeAssociationDepth';
 
 const { DateFilterDynamicComponent: DateFilterDynamicComponentLazy } = lazy(
   () => import('../../models/blocks/filter-form/fields/date-time/components/DateFilterDynamicComponent'),
@@ -85,6 +86,14 @@ export interface VariableFilterItemProps {
    */
   rightMetaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
   ignoreFieldNames?: string[];
+  maxAssociationFieldDepth?: number;
+}
+
+function limitMetaTreeIfNeeded(nodes: MetaTreeNode[], maxAssociationFieldDepth?: number) {
+  if (typeof maxAssociationFieldDepth !== 'number') {
+    return nodes;
+  }
+  return limitAssociationMetaTree(nodes, { maxAssociationDepth: maxAssociationFieldDepth });
 }
 
 function createStaticInputRenderer(
@@ -260,7 +269,7 @@ function normalizeRightValueInput(input: unknown) {
  * 上下文筛选项组件
  */
 export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
-  ({ value, model, rightAsVariable, rightMetaTree, ignoreFieldNames }) => {
+  ({ value, model, rightAsVariable, rightMetaTree, ignoreFieldNames, maxAssociationFieldDepth }) => {
     // 使用 View 上下文，确保可访问 ctx.view 的异步子树
     const ctx = useFlowViewContext();
     const t = model.translate;
@@ -539,13 +548,22 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         const nodes: MetaTreeNode[] = Array.isArray(raw)
           ? (raw as MetaTreeNode[])
           : await (raw as () => Promise<MetaTreeNode[]>)();
-        return [
-          { title: t('Constant'), name: 'constant', type: 'string', paths: ['constant'], render: staticInputRenderer },
-          { title: t('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          ...nodes,
-        ];
+        return limitMetaTreeIfNeeded(
+          [
+            {
+              title: t('Constant'),
+              name: 'constant',
+              type: 'string',
+              paths: ['constant'],
+              render: staticInputRenderer,
+            },
+            { title: t('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
+            ...nodes,
+          ],
+          maxAssociationFieldDepth,
+        );
       };
-    }, [rightMetaTree, ctx, staticInputRenderer, NullComponent, t]);
+    }, [rightMetaTree, ctx, staticInputRenderer, NullComponent, t, maxAssociationFieldDepth]);
 
     // 当启用右侧变量输入时，构造 VariableInput 的 converters：
     // - 变量模式：返回 null 让 VariableInput 渲染 VariableTag
@@ -629,9 +647,9 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         for (const n of nodes) {
           out.push(await enhanceNode(n));
         }
-        return out;
+        return limitMetaTreeIfNeeded(out, maxAssociationFieldDepth);
       };
-    }, [getFieldInterface, model]);
+    }, [getFieldInterface, model, maxAssociationFieldDepth]);
 
     return (
       <Space wrap style={{ width: '100%' }}>

package/src/flow/components/filter/__tests__/fieldsToOptions.test.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+
+import { fieldsToOptions } from '../fieldsToOptions';
+
+describe('fieldsToOptions', () => {
+  it('skips nested fields when target collection is unavailable', () => {
+    const field = {
+      name: 'space',
+      type: 'belongsTo',
+      target: 'spaces',
+      title: 'Space',
+      interface: 'm2o',
+      filterable: true,
+      uiSchema: {},
+      getInterfaceOptions: () => ({
+        filterable: {
+          nested: true,
+          operators: [{ value: '$eq', label: 'is' }],
+        },
+      }),
+      getFields: () => {
+        throw new Error('Target collection spaces not found for field space');
+      },
+    };
+
+    expect(() => fieldsToOptions([field], 1, [], (key: string) => key)).not.toThrow();
+    expect(fieldsToOptions([field], 1, [], (key: string) => key)).toEqual([
+      {
+        name: 'space',
+        type: 'belongsTo',
+        target: 'spaces',
+        title: 'Space',
+        schema: {},
+        operators: [{ value: '$eq', label: 'is' }],
+        children: [],
+      },
+    ]);
+  });
+});

package/src/flow/components/filter/__tests__/metaTreeAssociationDepth.test.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import type { MetaTreeNode } from '@nocobase/flow-engine';
+import { limitAssociationMetaTree } from '../metaTreeAssociationDepth';
+
+describe('limitAssociationMetaTree', () => {
+  it('keeps relation / relation / normal field and removes deeper relation fields', async () => {
+    const tree: MetaTreeNode[] = [
+      {
+        name: 'user',
+        title: 'User',
+        type: 'object',
+        interface: 'm2o',
+        options: { target: 'users' },
+        paths: ['collection', 'user'],
+        children: async () => [
+          {
+            name: 'department',
+            title: 'Department',
+            type: 'object',
+            interface: 'm2o',
+            options: { target: 'departments' },
+            paths: ['collection', 'user', 'department'],
+            children: async () => [
+              {
+                name: 'name',
+                title: 'Name',
+                type: 'string',
+                interface: 'input',
+                paths: ['collection', 'user', 'department', 'name'],
+              },
+              {
+                name: 'company',
+                title: 'Company',
+                type: 'object',
+                interface: 'm2o',
+                options: { target: 'companies' },
+                paths: ['collection', 'user', 'department', 'company'],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const limited = limitAssociationMetaTree(tree);
+    const userChildren = await (limited[0].children as () => Promise<MetaTreeNode[]>)();
+    const departmentChildren = await (userChildren[0].children as () => Promise<MetaTreeNode[]>)();
+
+    expect(departmentChildren.map((node) => node.name)).toEqual(['name']);
+  });
+});

package/src/flow/components/filter/fieldsToOptions.ts

@@ -59,10 +59,15 @@ const field2option = (field: CollectionField, depth, nonfilterable, t) => {
     option['children'] = children;
   }
   if (nested) {
-    const targetFields = field.getFields().filter((f) => {
-      // 过滤掉附件字段，因为会报错：Target collection attachments not found for field xxx
-      return f.target !== 'attachments' && f.interface !== 'formula';
-    });
+    let targetFields: CollectionField[] = [];
+    try {
+      targetFields = field.getFields().filter((f) => {
+        // 过滤掉附件字段，因为会报错：Target collection attachments not found for field xxx
+        return f.target !== 'attachments' && f.interface !== 'formula';
+      });
+    } catch {
+      targetFields = [];
+    }
     const options = fieldsToOptions(targetFields, depth + 1, nonfilterable, t).filter(Boolean);
     option['children'] = option['children'] || [];
     option['children'].push(...options);

package/src/flow/components/filter/index.ts

@@ -15,3 +15,6 @@ export { VariableFilterItem } from './VariableFilterItem';
 export type { VariableFilterItemProps, VariableFilterItemValue } from './VariableFilterItem';
 export { LinkageFilterItem } from './LinkageFilterItem';
 export type { LinkageFilterItemProps, LinkageFilterItemValue } from './LinkageFilterItem';
+export { useFilterOptions } from './useFilterOptions';
+export type { FilterOption, UseFilterOptionsArgs } from './useFilterOptions';
+// Higher-level filter compositions (`CollectionFilterItem`, `useFilterActionProps`, `createCollectionFilterItem`) live under `src/components/form/filter/`. They compose these flow primitives on top of a `Collection` binding — the dependency direction is form/filter → flow/components/filter, never the reverse.

package/src/flow/components/filter/metaTreeAssociationDepth.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 type { MetaTreeNode } from '@nocobase/flow-engine';
+
+const ASSOCIATION_FIELD_INTERFACES = new Set(['m2o', 'o2o', 'oho', 'obo', 'o2m', 'm2m', 'linkTo']);
+
+function isAssociationMetaNode(node: MetaTreeNode) {
+  const options = (node as any)?.options || {};
+  return Boolean(
+    options.target ||
+      options.targetCollection ||
+      options.foreignKey ||
+      options.through ||
+      ASSOCIATION_FIELD_INTERFACES.has(String(node?.interface || '')),
+  );
+}
+
+function limitNodeAssociationDepth(node: MetaTreeNode, associationDepth: number, maxAssociationDepth: number) {
+  const isAssociation = isAssociationMetaNode(node);
+  const nextAssociationDepth = associationDepth + (isAssociation ? 1 : 0);
+
+  if (isAssociation && nextAssociationDepth > maxAssociationDepth) {
+    return null;
+  }
+
+  const wrapChildren = (children: MetaTreeNode[] | (() => Promise<MetaTreeNode[]>)) => {
+    if (Array.isArray(children)) {
+      return limitAssociationMetaTree(children, {
+        associationDepth: nextAssociationDepth,
+        maxAssociationDepth,
+      });
+    }
+
+    return async () => {
+      const loaded = await children();
+      return limitAssociationMetaTree(Array.isArray(loaded) ? loaded : [], {
+        associationDepth: nextAssociationDepth,
+        maxAssociationDepth,
+      });
+    };
+  };
+
+  return {
+    ...node,
+    children: node.children ? wrapChildren(node.children as any) : undefined,
+  } as MetaTreeNode;
+}
+
+export function limitAssociationMetaTree(
+  nodes: MetaTreeNode[] | undefined,
+  options: {
+    associationDepth?: number;
+    maxAssociationDepth?: number;
+  } = {},
+): MetaTreeNode[] {
+  const { associationDepth = 0, maxAssociationDepth = 2 } = options;
+  if (!Array.isArray(nodes)) return [];
+
+  return nodes
+    .map((node) => limitNodeAssociationDepth(node, associationDepth, maxAssociationDepth))
+    .filter(Boolean) as MetaTreeNode[];
+}

package/src/flow/components/filter/useFilterOptions.ts

@@ -0,0 +1,102 @@
+/**
+ * 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 type { Collection } from '@nocobase/flow-engine';
+import { useMemo } from 'react';
+import { fieldsToOptions } from './fieldsToOptions';
+
+/**
+ * One operator entry on a `FilterOption`. Mirrors v1's interface-defined operator shape so the v2 filter value renderer can pick up the same per-operator value-side schema (e.g. datetime operators wanting the smart date picker, array/enum operators wanting a tag-mode Select).
+ */
+export type FilterOperator = {
+  value: string;
+  label: string;
+  /**
+   * Per-operator override for the value-side renderer. Wins over the field's own `uiSchema` when set. The `x-component` string is looked up against the v2 filter component registry.
+   */
+  schema?: { 'x-component'?: string; 'x-component-props'?: Record<string, any> } & Record<string, any>;
+  /** Operator takes no right-hand value (e.g. `$empty`, `$notEmpty`). */
+  noValue?: boolean;
+  [key: string]: any;
+};
+
+/** Single field-tree node returned by `useFilterOptions`. */
+export type FilterOption = {
+  name: string;
+  type?: string;
+  target?: string;
+  title: string;
+  schema?: Record<string, any>;
+  operators?: FilterOperator[];
+  children?: FilterOption[];
+};
+
+export interface UseFilterOptionsArgs {
+  /**
+   * **Preferred way to restrict fields**, alongside `nonfilterableFieldNames`.
+   *
+   * Whitelist of root-level field names to expose. Empty/undefined means "all filterable fields". The whitelist applies only at depth 1 — nested fields under an allowed association field are always included, matching the legacy v1 `Filter.Action` behaviour.
+   */
+  filterableFieldNames?: string[];
+  /**
+   * **Preferred way to restrict fields**, alongside `filterableFieldNames`.
+   *
+   * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` schema prop on `Filter.Action`. Applies at depth 1 only, same as the whitelist. When both `filterableFieldNames` and `nonfilterableFieldNames` are provided, both apply: the final field set is `(whitelist or all) minus blacklist`.
+   */
+  nonfilterableFieldNames?: string[];
+  /**
+   * Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`).
+   *
+   * Legacy escape hatch from v1 schemas — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead. Kept only for parity with existing v1 schemas that already set `noIgnore`.
+   */
+  noIgnore?: boolean;
+  /** Translator used for field/operator labels. Defaults to identity. */
+  t?: (key: string) => string;
+}
+
+const identity = (s: string) => s;
+
+/**
+ * v2 equivalent of v1's `useFilterOptions`/`useFilterFieldOptions`. Walks a `Collection`'s fields and returns the nested option tree consumed by antd `Cascader` in `CollectionFilterItem` (and any other v2 filter surface that wants the same field picker).
+ *
+ * Mirrors v1 in two ways that matter:
+ * - association fields (belongsTo / hasMany / m2m / etc.) are kept and recursed into via `fieldsToOptions`'s `nested` branch — so picking `user.username` is a first-class action, just like the legacy cascader.
+ * - the whitelist applies at depth 1 only, so capping the root field list (e.g. to `['lockedTs', 'unlockTs', 'user']`) doesn't accidentally hide the nested `user.username` / `user.nickname` leaves.
+ */
+export function useFilterOptions(collection: Collection | undefined, args: UseFilterOptionsArgs = {}): FilterOption[] {
+  const { filterableFieldNames, nonfilterableFieldNames, noIgnore = false, t = identity } = args;
+
+  const fields = useMemo(() => collection?.getFields() || [], [collection]);
+
+  const ignoreFieldsNames = useMemo(() => {
+    // Whitelist contribution: every field not in `filterableFieldNames`.
+    // Skipped when `noIgnore` is set, or when no whitelist was provided.
+    const whitelistIgnored =
+      noIgnore || !filterableFieldNames?.length
+        ? []
+        : fields.map((f) => f.name).filter((n) => !filterableFieldNames.includes(n));
+    // Blacklist contribution: explicit names. Always applied, even with
+    // `noIgnore` (the blacklist's whole job is to subtract specific fields).
+    const blacklistIgnored = nonfilterableFieldNames ?? [];
+    if (!blacklistIgnored.length) return whitelistIgnored;
+    // Union the two so the final ignore set is `whitelist-derived ∪ blacklist`.
+    return Array.from(new Set([...whitelistIgnored, ...blacklistIgnored]));
+  }, [fields, filterableFieldNames, nonfilterableFieldNames, noIgnore]);
+
+  return useMemo(
+    () =>
+      fieldsToOptions(
+        fields.filter((field) => field.target !== 'attachments' && field.interface !== 'formula'),
+        1,
+        ignoreFieldsNames,
+        t,
+      ).filter(Boolean) as FilterOption[],
+    [fields, ignoreFieldsNames, t],
+  );
+}

package/src/flow/index.ts

@@ -100,7 +100,11 @@ export * from './utils';
 export * from './actions';
 export * from './system-settings';
 export * from './admin-shell/admin-layout';
+export * from './admin-shell/BaseLayoutModel';
+export * from './admin-shell/BaseLayoutRouteCoordinator';
 export * from './admin-shell/AdminLayoutRouteCoordinator';
+export * from './admin-shell/useLayoutRoutePage';
+export * from './admin-shell/useAdminLayoutRoutePage';
 export * from '../settings-center';
 export { openViewFlow } from './flows/openViewFlow';
 export { editMarkdownFlow } from './flows/editMarkdownFlow';

package/src/flow/models/actions/FilterActionModel.tsx

@@ -75,7 +75,12 @@ export class FilterActionModel extends ActionModel {
                 value={this.props.filterValue || this.props.defaultFilterValue}
                 ctx={this.context}
                 FilterItem={(props) => (
-                  <VariableFilterItem {...props} model={this} ignoreFieldNames={this.getIgnoreFieldNames()} />
+                  <VariableFilterItem
+                    {...props}
+                    model={this}
+                    ignoreFieldNames={this.getIgnoreFieldNames()}
+                    maxAssociationFieldDepth={2}
+                  />
                 )}
               />
               <div style={{ height: 150 }}></div>
@@ -94,7 +99,12 @@ export class FilterActionModel extends ActionModel {
             value={this.props.filterValue || this.props.defaultFilterValue}
             ctx={this.context}
             FilterItem={(props) => (
-              <VariableFilterItem {...props} model={this} ignoreFieldNames={this.getIgnoreFieldNames()} />
+              <VariableFilterItem
+                {...props}
+                model={this}
+                ignoreFieldNames={this.getIgnoreFieldNames()}
+                maxAssociationFieldDepth={2}
+              />
             )}
           />
         }
@@ -187,7 +197,9 @@ FilterActionModel.registerFlow({
             return (
               <FilterGroup
                 value={props.value || {}}
-                FilterItem={(props) => <VariableFilterItem {...props} model={modelInstance} />}
+                FilterItem={(props) => (
+                  <VariableFilterItem {...props} model={modelInstance} maxAssociationFieldDepth={2} />
+                )}
               />
             );
           },

package/src/flow/models/actions/UpdateRecordActionModel.tsx

@@ -7,75 +7,22 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { tExpr, FlowModelRenderer, useFlowEngine, useFlowSettingsContext } from '@nocobase/flow-engine';
+import { tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
 import { Alert, ButtonProps } from 'antd';
-import React, { useEffect, useRef } from 'react';
+import React from 'react';
 import { AxiosRequestConfig } from 'axios';
 import { ActionModel, ActionSceneEnum } from '../base/ActionModel';
-import { CollectionActionModel } from '../base/CollectionActionModel';
-import { RecordActionModel } from '../base/RecordActionModel';
 import { AssignFormModel } from '../blocks/assign-form/AssignFormModel';
+import {
+  createAssignFieldValuesStep,
+  createAssignFormSubModelOptions,
+  getAssignFieldValuesDefaultParams,
+} from '../blocks/assign-form/assignFieldValuesFlow';
 import { applyUpdateRecordAction } from './UpdateRecordActionUtils';
 // import { RemoteFlowModelRenderer } from '../../FlowPage';
 
 const SETTINGS_FLOW_KEY = 'assignSettings';
 
-// 配置态编辑器：渲染 assignForm 子模型
-function AssignFieldsEditor() {
-  const { model, blockModel } = useFlowSettingsContext();
-  const action: any = model;
-  const engine = useFlowEngine();
-  const initializedRef = useRef(false);
-  const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
-
-  // 初始化回填
-  useEffect(() => {
-    let cancelled = false;
-    (async () => {
-      const loaded = (await engine.loadOrCreateModel(
-        {
-          parentId: action.uid,
-          subKey: 'assignForm',
-          use: 'AssignFormModel',
-        },
-        { skipSave: !model.context.flowSettingsEnabled },
-      )) as AssignFormModel;
-      if (cancelled) return;
-      setFormModel(loaded);
-      action.assignFormUid = (loaded as any)?.uid || action.assignFormUid;
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [action, engine]);
-
-  // 初始化回填（在子模型加载完成后）
-  useEffect(() => {
-    if (initializedRef.current) return;
-    if (!formModel) return;
-    const prev = action.getStepParams?.(SETTINGS_FLOW_KEY, 'assignFieldValues') || {};
-    // 注入资源上下文：与所在表格区块一致
-    const coll = blockModel?.collection || action?.context?.collection;
-    const dsKey = coll?.dataSourceKey;
-    const collName = coll?.name;
-    if (dsKey && collName) {
-      formModel.setStepParams('resourceSettings', 'init', {
-        dataSourceKey: dsKey,
-        collectionName: collName,
-      });
-    }
-    formModel.setInitialAssignedValues(prev?.assignedValues || {});
-    // 批量配置态：移除 ctx.record（Action 为区块级，不具备单条记录上下文）
-    const isBulk = action instanceof CollectionActionModel && !(action instanceof RecordActionModel);
-    if (isBulk && (formModel as any)?.context?.defineProperty) {
-      formModel.context.defineProperty('record', { get: () => undefined, cache: false });
-    }
-    initializedRef.current = true;
-  }, [action, blockModel?.collection, formModel]);
-
-  return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
-}
-
 function Info() {
   const ctx = useFlowSettingsContext();
   return (
@@ -124,16 +71,9 @@ UpdateRecordActionModel.define({
   sort: 50,
   // 使用函数型 createModelOptions，从父级上下文提取资源信息，直接注入到子模型的 resourceSettings.init
   createModelOptions: (ctx) => {
-    const dsKey = ctx.collection.dataSourceKey;
-    const collName = ctx.collection.name;
-    const init = dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
     return {
       subModels: {
-        assignForm: {
-          async: true,
-          use: 'AssignFormModel',
-          stepParams: { resourceSettings: { init } },
-        },
+        assignForm: createAssignFormSubModelOptions(ctx),
       },
     };
   },
@@ -155,32 +95,12 @@ UpdateRecordActionModel.registerFlow({
         content: tExpr('Are you sure you want to perform the Update record action?'),
       },
     },
-    assignFieldValues: {
+    assignFieldValues: createAssignFieldValuesStep({
+      settingsFlowKey: SETTINGS_FLOW_KEY,
       title: tExpr('Field values'),
-      uiSchema() {
-        return {
-          tip: {
-            'x-decorator': 'FormItem',
-            'x-component': () => <Info />,
-          },
-          editor: {
-            'x-decorator': 'FormItem',
-            'x-component': () => <AssignFieldsEditor />,
-          },
-        };
-      },
-      async beforeParamsSave(ctx) {
-        const m = ctx.model as UpdateRecordActionModel;
-        // 跨视图栈按 uid 定位到设置面板中的真实 AssignForm 实例
-        const form: AssignFormModel = m?.assignFormUid && ctx.engine.getModel?.(m.assignFormUid, true);
-        if (!form) return;
-        await form?.form?.validateFields?.();
-        const assignedValues = form?.getAssignedValues?.() || {};
-        const grid = form?.subModels?.grid;
-        const items = grid?.subModels?.items || [];
-        ctx.model.setStepParams(SETTINGS_FLOW_KEY, 'assignFieldValues', { assignedValues });
-      },
-    },
+      tipComponent: Info,
+      validateBeforeSave: true,
+    }),
   },
 });
 
@@ -190,8 +110,7 @@ UpdateRecordActionModel.registerFlow({
   steps: {
     apply: {
       async defaultParams(ctx) {
-        const step = ctx.model.getStepParams(SETTINGS_FLOW_KEY, 'assignFieldValues') || {};
-        return { assignedValues: step?.assignedValues || {} };
+        return getAssignFieldValuesDefaultParams(ctx, SETTINGS_FLOW_KEY);
       },
       async handler(ctx, params) {
         await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });

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

@@ -7,8 +7,9 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { MultiRecordResource, SingleRecordResource, resolveRunJSObjectValues } from '@nocobase/flow-engine';
+import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
 import { dispatchEventDeep } from '../../utils';
+import { resolveAssignFieldValues } from '../blocks/assign-form/assignFieldValuesFlow';
 
 export async function refreshLinkageRulesAfterUpdate(ctx: any) {
   const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
@@ -59,12 +60,8 @@ export async function applyUpdateRecordAction(
   const confirmParams = savedConfirm && typeof savedConfirm === 'object' ? savedConfirm : { enable: false };
   await ctx.runAction('confirm', confirmParams);
 
-  let assignedValues: Record<string, any> = {};
-  try {
-    assignedValues = await resolveRunJSObjectValues(ctx, params?.assignedValues);
-  } catch (error) {
-    console.error('[UpdateRecordAction] RunJS execution failed', error);
-    ctx.message.error(ctx.t('RunJS execution failed'));
+  const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'UpdateRecordAction');
+  if (!assignedValues) {
     return;
   }