@nocobase/client-v2 2.1.0-beta.38 → 2.1.0-beta.41

package/src/components/README.md

@@ -164,6 +164,7 @@ Key props:
 - `namespaces`: restrict the picker to specific top-level namespaces. Omit to expose every registered top-level property
 - `extraNodes`: static leaves appended after the namespace-filtered nodes. Use for variables that only make sense in the current page (e.g. `$resetLink`)
 - `converters`: override the default path ↔ string converters. `EnvVariableInput` uses this hook to lock its output to `$env`
+- `delimiters`: token pair wrapping the stored variable reference. Defaults to `['{{', '}}']` (Handlebars HTML-escaped). Pass `['{{{', '}}}']` for fields rendered as HTML where escaping would corrupt the variable value — e.g. the in-app message body
 - `value` / `onChange` / `placeholder` / `disabled`: standard controlled-input props
 
 Under the hood `VariableInput` wraps `VariableHybridInput` (inline pills), `VariableTextArea` wraps `TextAreaWithContextSelector` (textarea + variable button). Both share the same MetaTree.

package/src/components/README.zh-CN.md

@@ -164,6 +164,7 @@ import { VariableInput, VariableTextArea } from '@nocobase/client-v2';
 - `namespaces`：限定可选的顶层命名空间。不传就用 `flowEngine.context` 里全部已注册的
 - `extraNodes`：在命名空间过滤后追加几条静态变量（用于 `$resetLink` 这类只在当前页面有意义的局部变量）
 - `converters`：覆盖默认的 path ↔ string 转换器。`EnvVariableInput` 就是用这个钩子把输出锁定到 `$env`
+- `delimiters`：变量在存储字符串里使用的开闭分隔符，默认 `['{{', '}}']`（对应 Handlebars 的 HTML 转义形式）。若字段最终以 HTML 渲染、转义会破坏变量内容（如站内信正文），传 `['{{{', '}}}']` 走 Handlebars 的原样输出形式
 - `value` / `onChange` / `placeholder` / `disabled`：标准受控字段属性
 
 底层共用 `VariableHybridInput`（`VariableInput`）和 `TextAreaWithContextSelector`（`VariableTextArea`），用同一套 MetaTree 数据。

package/src/components/form/VariableInput.tsx

@@ -25,28 +25,75 @@ import { TextAreaWithContextSelector } from '../../flow/components/TextAreaWithC
  * stored values round-trip to a labelled pill instead of falling back to a
  * raw `{{…}}` literal.
  */
-const VARIABLE_EXPR_RE = /^\{\{\s*(.+?)\s*\}\}$/;
-
-export function parseVariablePath(value?: string): string[] | undefined {
-  if (typeof value !== 'string') return undefined;
-  const match = value.trim().match(VARIABLE_EXPR_RE);
-  if (!match) return undefined;
-  let pathString = match[1];
-  // Backwards-compat: accept the legacy `ctx.` prefix so values produced by
-  // pre-fix versions of the picker still resolve to a labelled pill.
-  if (pathString === 'ctx') return [];
-  if (pathString.startsWith('ctx.')) pathString = pathString.slice(4);
-  return pathString.split('.');
+
+/**
+ * Variable delimiters: opening + closing tokens. Default `['{{', '}}']`
+ * matches NocoBase server template convention (Handlebars HTML-escaped
+ * output). Pass `['{{{', '}}}']` to switch to Handlebars' raw/unescaped
+ * form — required for fields whose content is rendered as HTML (e.g.
+ * in-app message body) so the variable expansion bypasses HTML escaping.
+ *
+ * Restrict to literal-token pairs, since the regex builder escapes them
+ * verbatim.
+ */
+export type VariableDelimiters = readonly [string, string];
+
+const DEFAULT_DELIMITERS: VariableDelimiters = ['{{', '}}'];
+
+function escapeForRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-export function formatVariablePath(meta?: MetaTreeNode): string | undefined {
-  const paths = meta?.paths || [];
-  if (paths.length === 0) return undefined;
-  // No inner spaces — matches the v1 storage shape exactly so round-trips
-  // through the API stay byte-stable.
-  return `{{${paths.join('.')}}}`;
+/**
+ * Factory: returns a `parseValueToPath` bound to the given delimiters.
+ * Anchored (`^…$`) — only treats the whole input as a single variable
+ * reference, matching the v1 single-line picker behaviour.
+ */
+export function makeParseVariablePath(delimiters: VariableDelimiters = DEFAULT_DELIMITERS) {
+  const [open, close] = delimiters;
+  const re = new RegExp(`^${escapeForRegExp(open)}\\s*(.+?)\\s*${escapeForRegExp(close)}$`);
+  return (value?: string): string[] | undefined => {
+    if (typeof value !== 'string') return undefined;
+    const match = value.trim().match(re);
+    if (!match) return undefined;
+    let pathString = match[1];
+    // Backwards-compat: accept the legacy `ctx.` prefix so values produced by
+    // pre-fix versions of the picker still resolve to a labelled pill.
+    if (pathString === 'ctx') return [];
+    if (pathString.startsWith('ctx.')) pathString = pathString.slice(4);
+    return pathString.split('.');
+  };
 }
 
+/**
+ * Factory: returns a `formatPathToValue` bound to the given delimiters.
+ * No inner spaces — matches the v1 storage shape exactly so round-trips
+ * through the API stay byte-stable.
+ */
+export function makeFormatVariablePath(delimiters: VariableDelimiters = DEFAULT_DELIMITERS) {
+  const [open, close] = delimiters;
+  return (meta?: MetaTreeNode): string | undefined => {
+    const paths = meta?.paths || [];
+    if (paths.length === 0) return undefined;
+    return `${open}${paths.join('.')}${close}`;
+  };
+}
+
+/**
+ * Factory: returns a global regex matching every occurrence of the
+ * variable token within a longer string. Used by `VariableHybridInput`
+ * to render embedded variables as pills.
+ */
+export function makeVariableRegExp(delimiters: VariableDelimiters = DEFAULT_DELIMITERS): RegExp {
+  const [open, close] = delimiters;
+  return new RegExp(`${escapeForRegExp(open)}\\s*([^{}]+?)\\s*${escapeForRegExp(close)}`, 'g');
+}
+
+// Default exports — `{{ ... }}` for the most common case. Kept named so
+// existing callers don't need to switch to the factory.
+export const parseVariablePath = makeParseVariablePath();
+export const formatVariablePath = makeFormatVariablePath();
+
 const META_TREE_CACHE_PREFIX = '@nocobase/client-v2:VariableInput:metaTree';
 
 /**
@@ -123,8 +170,22 @@ export interface VariableInputProps {
    * Override the converters used by the underlying `VariableHybridInput`.
    * Mostly useful when the caller wants to constrain `formatPathToValue` to a
    * specific namespace (see `EnvVariableInput` for that pattern).
+   *
+   * Takes precedence over `delimiters` when both are set on the same field
+   * (an explicit converter wins over the delimiter-derived one).
    */
   converters?: VariableHybridInputConverters;
+  /**
+   * Token pair wrapping variable references in the stored string. Defaults
+   * to `['{{', '}}']` — the standard NocoBase server-template form,
+   * HTML-escaped by Handlebars. Pass `['{{{', '}}}']` for fields rendered
+   * as HTML where escaping would corrupt the variable value (e.g. the
+   * in-app message body).
+   *
+   * Ignored when `converters` is also supplied — caller-provided converters
+   * win.
+   */
+  delimiters?: VariableDelimiters;
   className?: string;
   style?: React.CSSProperties;
 }
@@ -136,16 +197,24 @@ export interface VariableInputProps {
  * line of mixed literal+variable content is appropriate.
  */
 export function VariableInput(props: VariableInputProps) {
-  const { namespaces, extraNodes, converters, ...rest } = props;
+  const { namespaces, extraNodes, converters, delimiters, ...rest } = props;
   const metaTree = useFilteredMetaTree({ namespaces, extraNodes });
-  const mergedConverters = useMemo<VariableHybridInputConverters>(
-    () => ({
-      formatPathToValue: formatVariablePath,
-      parseValueToPath: parseVariablePath,
+  const mergedConverters = useMemo<VariableHybridInputConverters>(() => {
+    // Default delimiters → reuse the pre-built singletons.
+    if (!delimiters) {
+      return {
+        formatPathToValue: formatVariablePath,
+        parseValueToPath: parseVariablePath,
+        ...converters,
+      };
+    }
+    return {
+      formatPathToValue: makeFormatVariablePath(delimiters),
+      parseValueToPath: makeParseVariablePath(delimiters),
+      variableRegExp: makeVariableRegExp(delimiters),
       ...converters,
-    }),
-    [converters],
-  );
+    };
+  }, [converters, delimiters]);
   return <VariableHybridInput {...rest} converters={mergedConverters} metaTree={metaTree} />;
 }
 
@@ -161,9 +230,13 @@ export interface VariableTextAreaProps extends Omit<VariableInputProps, 'convert
  * is desirable (the server expands them at render time).
  */
 export function VariableTextArea(props: VariableTextAreaProps) {
-  const { namespaces, extraNodes, rows, maxRows, style, ...rest } = props;
+  const { namespaces, extraNodes, rows, maxRows, style, delimiters, ...rest } = props;
   const metaTree = useFilteredMetaTree({ namespaces, extraNodes });
   const metaTreeGetter = useMemo(() => () => metaTree, [metaTree]);
+  const formatPathToValue = useMemo(
+    () => (delimiters ? makeFormatVariablePath(delimiters) : formatVariablePath),
+    [delimiters],
+  );
   return (
     <TextAreaWithContextSelector
       {...rest}
@@ -171,7 +244,7 @@ export function VariableTextArea(props: VariableTextAreaProps) {
       maxRows={maxRows}
       style={style}
       metaTree={metaTreeGetter}
-      formatPathToValue={(meta) => formatVariablePath(meta) ?? ''}
+      formatPathToValue={(meta) => formatPathToValue(meta) ?? ''}
     />
   );
 }

package/src/components/form/__tests__/VariableInput.test.ts

@@ -0,0 +1,85 @@
+/**
+ * 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 {
+  formatVariablePath,
+  makeFormatVariablePath,
+  makeParseVariablePath,
+  makeVariableRegExp,
+  parseVariablePath,
+} from '../VariableInput';
+
+describe('VariableInput delimiter helpers', () => {
+  describe('default delimiters {{ }}', () => {
+    it('formats meta nodes into `{{x.y}}` with no inner spaces', () => {
+      expect(formatVariablePath({ paths: ['$user', 'id'] } as any)).toBe('{{$user.id}}');
+    });
+
+    it('parses `{{x.y}}` into a path array', () => {
+      expect(parseVariablePath('{{ $user.id }}')).toEqual(['$user', 'id']);
+      expect(parseVariablePath('{{$user.id}}')).toEqual(['$user', 'id']);
+    });
+
+    it('strips a legacy `ctx.` prefix for backwards-compat', () => {
+      expect(parseVariablePath('{{ctx.$user.id}}')).toEqual(['$user', 'id']);
+      expect(parseVariablePath('{{ctx}}')).toEqual([]);
+    });
+
+    it('returns undefined for plain text', () => {
+      expect(parseVariablePath('hello world')).toBeUndefined();
+      expect(parseVariablePath('')).toBeUndefined();
+      expect(parseVariablePath(undefined)).toBeUndefined();
+    });
+  });
+
+  describe('triple-brace delimiters {{{ }}}', () => {
+    const format = makeFormatVariablePath(['{{{', '}}}']);
+    const parse = makeParseVariablePath(['{{{', '}}}']);
+
+    it('formats meta nodes into `{{{x.y}}}`', () => {
+      expect(format({ paths: ['$user', 'id'] } as any)).toBe('{{{$user.id}}}');
+    });
+
+    it('parses `{{{x.y}}}` into a path array', () => {
+      expect(parse('{{{$user.id}}}')).toEqual(['$user', 'id']);
+      expect(parse('{{{ $user.id }}}')).toEqual(['$user', 'id']);
+    });
+
+    it('does not match the double-brace form', () => {
+      expect(parse('{{$user.id}}')).toBeUndefined();
+    });
+  });
+
+  describe('makeVariableRegExp', () => {
+    it('matches every occurrence in a longer string under default delimiters', () => {
+      const re = makeVariableRegExp();
+      const matches = Array.from('hello {{ $user.id }} world {{ $env.X }}'.matchAll(re)).map((m) => m[1]);
+      expect(matches).toEqual(['$user.id', '$env.X']);
+    });
+
+    it('matches triple-brace occurrences when configured', () => {
+      const re = makeVariableRegExp(['{{{', '}}}']);
+      const matches = Array.from('hi {{{$user.id}}} :)'.matchAll(re)).map((m) => m[1]);
+      expect(matches).toEqual(['$user.id']);
+    });
+
+    it('does not match double-brace occurrences under triple-brace config', () => {
+      const re = makeVariableRegExp(['{{{', '}}}']);
+      const matches = Array.from('plain {{ x }} text'.matchAll(re));
+      expect(matches).toHaveLength(0);
+    });
+  });
+
+  it('handles empty paths consistently', () => {
+    expect(formatVariablePath({ paths: [] } as any)).toBeUndefined();
+    expect(formatVariablePath(undefined)).toBeUndefined();
+    expect(makeFormatVariablePath(['{{{', '}}}'])({ paths: [] } as any)).toBeUndefined();
+  });
+});

package/src/components/form/filter/CollectionFilter.tsx

@@ -25,7 +25,15 @@ export interface CollectionFilterProps {
   t?: (key: string, options?: Record<string, any>) => string;
   /** Whitelist of root-level field names to expose. */
   filterableFieldNames?: string[];
-  /** Bypass the `filterableFieldNames` whitelist. */
+  /**
+   * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both `filterableFieldNames` and this prop are supplied, both apply (final = whitelist ∩ ¬blacklist).
+   */
+  nonfilterableFieldNames?: string[];
+  /**
+   * Bypass the `filterableFieldNames` whitelist.
+   *
+   * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+   */
   noIgnore?: boolean;
   /** Override the trigger button's label. Defaults to `t('Filter')`, or the v1-style `t('{{count}} filter items', { count })` when conditions are present. */
   buttonText?: React.ReactNode;
@@ -50,6 +58,7 @@ export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
     onChange,
     t = identity,
     filterableFieldNames,
+    nonfilterableFieldNames,
     noIgnore,
     buttonText,
     showCount = true,
@@ -63,6 +72,7 @@ export const CollectionFilter: FC<CollectionFilterProps> = (props) => {
   const filterAction = useFilterActionProps({
     collection,
     filterableFieldNames,
+    nonfilterableFieldNames,
     noIgnore,
     t,
     onApply: (filter: CompiledFilter, action: FilterApplyAction) => {

package/src/components/form/filter/CollectionFilterItem.tsx

@@ -44,7 +44,15 @@ export interface CollectionFilterItemProps {
   collection: Collection;
   /** Whitelist of field names to expose; empty/undefined means all filterable fields. */
   filterableFieldNames?: string[];
-  /** Bypass the `filterableFieldNames` whitelist (matches the legacy FilterItem `noIgnore`). */
+  /**
+   * Blacklist of field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both whitelist and blacklist are supplied, both apply (final = whitelist ∩ ¬blacklist).
+   */
+  nonfilterableFieldNames?: string[];
+  /**
+   * Bypass the `filterableFieldNames` whitelist (matches the legacy FilterItem `noIgnore`).
+   *
+   * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+   */
   noIgnore?: boolean;
   /** Translator; defaults to identity so callers can omit it. */
   t?: (key: string) => string;
@@ -84,10 +92,10 @@ const toCascaderOptions = (options: FilterOption[]): CascaderOption[] =>
  */
 export const CollectionFilterItem: FC<CollectionFilterItemProps> = observer(
   (props) => {
-    const { collection, filterableFieldNames, noIgnore = false, t = identity } = props;
+    const { collection, filterableFieldNames, nonfilterableFieldNames, noIgnore = false, t = identity } = props;
     const { path: leftValue, operator, value: rightValue } = props.value;
 
-    const options = useFilterOptions(collection, { filterableFieldNames, noIgnore, t });
+    const options = useFilterOptions(collection, { filterableFieldNames, nonfilterableFieldNames, noIgnore, t });
 
     const cascaderOptions = useMemo(() => toCascaderOptions(options), [options]);
 
@@ -164,7 +172,7 @@ export const CollectionFilterItem: FC<CollectionFilterItemProps> = observer(
  */
 export function createCollectionFilterItem(
   collection: Collection,
-  bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'noIgnore' | 't'>,
+  bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'nonfilterableFieldNames' | 'noIgnore' | 't'>,
 ) {
   const Component: FC<{ value: CollectionFilterItemValue }> = (props) => (
     <CollectionFilterItem {...bound} value={props.value} collection={collection} />

package/src/components/form/filter/__tests__/CollectionFilterItem.test.tsx

@@ -136,6 +136,48 @@ describe('CollectionFilterItem', () => {
     expect(screen.queryByText('Lock reason')).not.toBeInTheDocument();
   });
 
+  it('honours nonfilterableFieldNames blacklist', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      { name: 'username', title: 'Username' },
+      { name: 'lockReason', title: 'Lock reason' },
+    ]);
+
+    const { container } = render(
+      <CollectionFilterItem value={value} collection={collection} nonfilterableFieldNames={['lockReason']} />,
+    );
+
+    openFieldCascader(container);
+    expect(await screen.findByText('Username')).toBeInTheDocument();
+    expect(screen.queryByText('Lock reason')).not.toBeInTheDocument();
+  });
+
+  it('applies both whitelist and blacklist (final = whitelist minus blacklist)', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      { name: 'username', title: 'Username' },
+      { name: 'nickname', title: 'Nickname' },
+      { name: 'lockReason', title: 'Lock reason' },
+    ]);
+
+    // Whitelist permits username + nickname; blacklist then subtracts nickname. Result: only username should appear.
+    const { container } = render(
+      <CollectionFilterItem
+        value={value}
+        collection={collection}
+        filterableFieldNames={['username', 'nickname']}
+        nonfilterableFieldNames={['nickname']}
+      />,
+    );
+
+    openFieldCascader(container);
+    expect(await screen.findByText('Username')).toBeInTheDocument();
+    // nickname is whitelisted but also blacklisted — blacklist wins for that field.
+    expect(screen.queryByText('Nickname')).not.toBeInTheDocument();
+    // lockReason isn't in the whitelist either, so it stays hidden.
+    expect(screen.queryByText('Lock reason')).not.toBeInTheDocument();
+  });
+
   it('writes through value.value on input change', () => {
     const value = observable({ path: 'username', operator: '$eq', value: '' });
     const collection = buildStubCollection([{ name: 'username', title: 'Username' }]);

package/src/components/form/filter/useFilterActionProps.ts

@@ -152,7 +152,7 @@ export interface UseFilterActionPropsResult {
  * ```
  */
 export function useFilterActionProps(args: UseFilterActionPropsArgs): UseFilterActionPropsResult {
-  const { collection, onApply, filterableFieldNames, noIgnore, t } = args;
+  const { collection, onApply, filterableFieldNames, nonfilterableFieldNames, noIgnore, t } = args;
 
   // Held in a ref so the group object identity is stable for the lifetime of the host component — `<FilterContent>` mutates this object directly (push/splice on `items`, swap `logic`), and a fresh observable on every render would reset that internal state.
   const valueRef = useRef<FilterGroupValue>();
@@ -161,11 +161,14 @@ export function useFilterActionProps(args: UseFilterActionPropsArgs): UseFilterA
   }
   const value = valueRef.current;
 
-  const options = useFilterOptions(collection, { filterableFieldNames, noIgnore, t });
+  const options = useFilterOptions(collection, { filterableFieldNames, nonfilterableFieldNames, noIgnore, t });
 
   const FilterItem = useMemo(
-    () => (collection ? createCollectionFilterItem(collection, { filterableFieldNames, noIgnore, t }) : undefined),
-    [collection, filterableFieldNames, noIgnore, t],
+    () =>
+      collection
+        ? createCollectionFilterItem(collection, { filterableFieldNames, nonfilterableFieldNames, noIgnore, t })
+        : undefined,
+    [collection, filterableFieldNames, nonfilterableFieldNames, noIgnore, t],
   );
 
   const onSubmit = useMemoizedFn(() => {

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

@@ -39,10 +39,22 @@ export type 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[];
-  /** Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`). */
+  /**
+   * **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;
@@ -58,14 +70,24 @@ const identity = (s: string) => s;
  * - 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, noIgnore = false, t = identity } = args;
+  const { filterableFieldNames, nonfilterableFieldNames, noIgnore = false, t = identity } = args;
 
   const fields = useMemo(() => collection?.getFields() || [], [collection]);
 
   const ignoreFieldsNames = useMemo(() => {
-    if (noIgnore || !filterableFieldNames?.length) return [];
-    return fields.map((f) => f.name).filter((n) => !filterableFieldNames.includes(n));
-  }, [fields, filterableFieldNames, noIgnore]);
+    // 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(
     () =>

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;
   }