@nocobase/client-v2 2.1.8 → 2.1.9

package/src/flow/actions/__tests__/linkageAssignField.legacy.test.ts

@@ -69,6 +69,72 @@ describe('linkage assign actions - legacy params', () => {
     expect(setProps).not.toHaveBeenCalledWith(fieldModel, { value: 'default-in-update' });
   });
 
+  it('linkageAssignField should mark override mode for field targets', async () => {
+    const fieldModel: any = { uid: 'f-override', fieldPath: 'a.b' };
+    const ctx: any = {
+      model: {
+        subModels: { grid: { subModels: { items: [fieldModel] } } },
+      },
+      engine: { getModel: vi.fn(() => ({ fieldPath: 'a.b' })) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override',
+          enable: true,
+          targetPath: 'a.b',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-value',
+        },
+      ],
+      setProps,
+    });
+
+    expect(setProps).toHaveBeenCalledTimes(1);
+    const [, props] = setProps.mock.calls[0];
+    expect(props).toMatchObject({
+      value: 'override-value',
+      __linkageAssignMode: 'override',
+    });
+  });
+
+  it('linkageAssignField should emit override patches for targets without form item models', async () => {
+    const ctx: any = {
+      model: { subModels: { grid: { subModels: { items: [] } } } },
+      engine: { getModel: vi.fn(() => null) },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const setProps = vi.fn();
+    const addFormValuePatch = vi.fn();
+
+    await linkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-direct',
+          enable: true,
+          targetPath: 'user.name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-direct',
+        },
+      ],
+      setProps,
+      addFormValuePatch,
+    });
+
+    expect(setProps).not.toHaveBeenCalled();
+    expect(addFormValuePatch).toHaveBeenCalledWith({
+      path: 'user.name',
+      value: 'override-direct',
+      whenEmpty: false,
+      mode: 'override',
+    });
+  });
+
   it('subFormLinkageAssignField should apply legacy object params at runtime', () => {
     const forkModel: any = {
       uid: 'f1',
@@ -381,6 +447,75 @@ describe('linkage assign actions - legacy params', () => {
     expect(addFormValuePatch).toHaveBeenCalledTimes(1);
   });
 
+  it('subFormLinkageAssignField should skip override patch after user edits the target path', () => {
+    const ctx: any = {
+      model: {
+        uid: 'sub-form-override-path',
+        getAclActionName: vi.fn(() => 'create'),
+        context: {},
+        parent: {
+          getStepParams: (flowKey: string, stepKey: string) => {
+            if (flowKey === 'fieldSettings' && stepKey === 'init') {
+              return { fieldPath: 'M2M.M2M' };
+            }
+            return {};
+          },
+        },
+        subModels: { grid: { subModels: { items: [] } } },
+      },
+      engine: {
+        getModel: vi.fn(() => null),
+      },
+      app: { jsonLogic: { apply: vi.fn() } },
+    };
+    const addFormValuePatch = vi.fn();
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-1',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-1',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+    expect(addFormValuePatch).toHaveBeenNthCalledWith(1, {
+      path: 'M2M.M2M.Name',
+      value: 'override-1',
+      whenEmpty: false,
+      mode: 'override',
+    });
+
+    ctx.inputArgs = {
+      source: 'user',
+      changedPaths: [['M2M', 'M2M', 'Name']],
+    };
+
+    subFormLinkageAssignField.handler(ctx, {
+      value: [
+        {
+          key: 'r-override-path-2',
+          enable: true,
+          targetPath: 'Name',
+          mode: 'override',
+          condition: { logic: '$and', items: [] },
+          value: 'override-2',
+        },
+      ],
+      addFormValuePatch,
+      setProps: vi.fn(),
+    });
+
+    expect(addFormValuePatch).toHaveBeenCalledTimes(1);
+  });
+
   it('linkageAssignField should evaluate RunJS value before assign', async () => {
     const fieldModel: any = { uid: 'f-runjs-assign', fieldPath: 'a.b' };
     const runjs = vi.fn(async () => ({ success: true, value: 'from-runjs' }));

package/src/flow/actions/linkageRules.tsx

@@ -40,7 +40,7 @@ import { FilterGroup } from '../components/filter/FilterGroup';
 import { LinkageFilterItem } from '../components/filter';
 import { CodeEditor } from '../components/code-editor';
 import { FieldAssignRulesEditor } from '../components/FieldAssignRulesEditor';
-import type { FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
+import type { AssignMode, FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
 import { collectFieldAssignCascaderOptions } from '../components/fieldAssignOptions';
 import { useAssociationTitleFieldSync } from '../components/useAssociationTitleFieldSync';
 import _ from 'lodash';
@@ -888,6 +888,20 @@ type ArrayFieldComponentProps = {
 
 const LEGACY_ASSIGN_RULE = { mode: 'assign', valueKey: 'assignValue' } as const;
 const LEGACY_DEFAULT_RULE = { mode: 'default', valueKey: 'initialValue' } as const;
+const LINKAGE_ASSIGN_MODE_PROP = '__linkageAssignMode';
+
+function normalizeLinkageAssignMode(mode: unknown): AssignMode {
+  if (mode === 'default') return 'default';
+  if (mode === 'override') return 'override';
+  return 'assign';
+}
+
+type LinkageValuePatch = {
+  path: Array<string | number>;
+  value: unknown;
+  whenEmpty?: boolean;
+  mode?: AssignMode;
+};
 
 const FieldAssignRulesActionComponent: React.FC<
   ArrayFieldComponentProps & {
@@ -1002,16 +1016,24 @@ export const linkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         if (fieldModel) {
           if (mode === 'default') {
             setProps(fieldModel as FlowModel, { initialValue: finalValue });
           } else {
-            setProps(fieldModel as FlowModel, { value: finalValue });
+            setProps(fieldModel as FlowModel, {
+              value: finalValue,
+              ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+            });
           }
         } else if (typeof addFormValuePatch === 'function') {
           // 对关联字段子属性（如 user.name）等没有独立 FormItemModel 的目标，直接写入表单值
-          addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+          addFormValuePatch({
+            path: targetPath,
+            value: finalValue,
+            whenEmpty: mode === 'default',
+            ...(mode === 'override' ? { mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1177,7 +1199,7 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         const actionName = (ctx.model as any)?.getAclActionName?.() ?? (ctx.model as any)?.context?.actionName;
         const isEditForm = actionName === 'update';
         const isNewItem = (ctx as any)?.item?.__is_new__ === true;
@@ -1207,12 +1229,21 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
+        if (mode === 'override' && hasExplicitPathHit(targetPath)) {
+          continue;
+        }
+
         if (!fieldUid) {
           if (mode === 'default' && hasExplicitPathHit(targetPath)) {
             continue;
           }
           if (typeof addFormValuePatch === 'function') {
-            addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+            addFormValuePatch({
+              path: targetPath,
+              value: finalValue,
+              whenEmpty: mode === 'default',
+              ...(mode === 'override' ? { mode } : {}),
+            });
           }
           continue;
         }
@@ -1223,7 +1254,10 @@ export const subFormLinkageAssignField = defineAction({
         if (mode === 'default') {
           setProps(model, { initialValue: finalValue });
         } else {
-          setProps(model, { value: finalValue });
+          setProps(model, {
+            value: finalValue,
+            ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1781,7 +1815,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const modelsToApply = new Set<FlowModel>(allModels);
   const patchPropsByModel = new Map<FlowModel, any>();
   const clearValueOnHiddenModelUids = new Set<string>();
-  const directValuePatches: Array<{ path: Array<string | number>; value: any; whenEmpty?: boolean }> = [];
+  const directValuePatches: LinkageValuePatch[] = [];
   const rootCollection = getCollectionFromModel((ctx.model as any)?.context?.blockModel ?? ctx.model);
   const isSafeToWriteAssociationSubpath = (namePath: any): boolean => {
     if (!Array.isArray(namePath) || !namePath.length) return true;
@@ -1836,13 +1870,18 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     }
 
     for (const patch of lastPatchByPathKey.values()) {
-      if (!patch.whenEmpty) continue;
+      if (!patch.whenEmpty && patch.mode !== 'default') continue;
       runtime.recordDefaultValuePatch(patch.path, patch.value);
     }
   };
-  const addFormValuePatch = (patch: { path: any; value: any; whenEmpty?: boolean }) => {
+  const getPatchMode = (patch: { mode?: unknown; whenEmpty?: boolean }): AssignMode => {
+    if (patch?.mode === 'default') return 'default';
+    if (patch?.mode === 'override') return 'override';
+    return patch?.whenEmpty ? 'default' : 'assign';
+  };
+  const addFormValuePatch = (patch: { path: unknown; value: unknown; whenEmpty?: boolean; mode?: AssignMode }) => {
     if (!patch) return;
-    const path = (patch as any)?.path;
+    const path = patch.path;
     if (!path) return;
     const resolvedPath = resolveNamePathForPatch(path);
     if (!resolvedPath) {
@@ -1862,8 +1901,9 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       });
       return;
     }
-    const whenEmpty = !!(patch as any)?.whenEmpty;
-    const value = (patch as any)?.value;
+    const mode = getPatchMode(patch);
+    const whenEmpty = mode === 'default';
+    const value = patch.value;
     try {
       const form = ctx.model?.context?.form;
       const current = form?.getFieldValue?.(resolvedPath);
@@ -1878,6 +1918,15 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           return;
         }
       }
+      if (mode === 'override') {
+        const runtime = getDefaultPatchRuntime();
+        if (
+          typeof runtime?.canApplyOverrideValuePatch === 'function' &&
+          !runtime.canApplyOverrideValuePatch(resolvedPath)
+        ) {
+          return;
+        }
+      }
       if (_.isEqual(current, value)) {
         return;
       }
@@ -1889,6 +1938,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       path: resolvedPath,
       value,
       ...(whenEmpty ? { whenEmpty: true } : {}),
+      ...(mode === 'override' ? { mode } : {}),
     });
   };
   const removePendingFormValuePatches = (path: any) => {
@@ -2116,6 +2166,14 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     for (const action of actions) {
       const setProps = (model: FlowModel & { __originalProps?: any; __shouldReset?: boolean }, props: any) => {
+        const normalizedProps =
+          props && typeof props === 'object' && Object.prototype.hasOwnProperty.call(props, 'value')
+            ? {
+                ...props,
+                [LINKAGE_ASSIGN_MODE_PROP]: normalizeLinkageAssignMode(props?.[LINKAGE_ASSIGN_MODE_PROP]),
+              }
+            : props;
+
         // 存储原始值，用于恢复
         if (!model.__originalProps) {
           model.__originalProps = {
@@ -2131,7 +2189,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
         // 临时存起来，遍历完所有规则后，再统一处理
         patchPropsByModel.set(model, {
           ...(patchPropsByModel.get(model) || {}),
-          ...props,
+          ...normalizedProps,
         });
 
         if (
@@ -2185,7 +2243,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     const prevHidden = !!model.hidden;
     const nextHidden = !!newProps.hiddenModel;
 
-    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
+    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText', LINKAGE_ASSIGN_MODE_PROP]));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(nextHidden);
@@ -2224,7 +2282,8 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           targetUid: model?.uid,
         });
       } else {
-        addFormValuePatch({ path: targetPath, value: newProps.value });
+        const mode = normalizeLinkageAssignMode(patchProps?.[LINKAGE_ASSIGN_MODE_PROP]);
+        addFormValuePatch({ path: targetPath, value: newProps.value, ...(mode === 'override' ? { mode } : {}) });
       }
     }
 

package/src/flow/components/FieldAssignRulesEditor.tsx

@@ -28,7 +28,7 @@ import { buildFieldAssignCascaderOptionsFromCollection, type FieldAssignCascader
 import { isRunJSValue, isVariableExpression, type MetaTreeNode } from '@nocobase/flow-engine';
 import { isToManyAssociationField } from '../internal/utils/modelUtils';
 
-export type AssignMode = 'default' | 'assign';
+export type AssignMode = 'default' | 'assign' | 'override';
 
 type CollectionFieldLike = {
   name?: unknown;
@@ -89,6 +89,8 @@ export interface FieldAssignRulesEditorProps {
   defaultMode?: AssignMode;
   /** 固定 mode：用于“仅默认值/仅赋值”的场景 */
   fixedMode?: AssignMode;
+  /** 可选 mode 列表；fixedMode 优先级更高 */
+  allowedModes?: AssignMode[];
   /** 是否显示 condition */
   showCondition?: boolean;
   /** 是否显示 enable 开关 */
@@ -109,6 +111,23 @@ export interface FieldAssignRulesEditorProps {
   maxAssociationFieldDepth?: number;
 }
 
+const ALL_ASSIGN_MODES: AssignMode[] = ['default', 'override', 'assign'];
+
+function isAssignMode(mode: unknown): mode is AssignMode {
+  return mode === 'default' || mode === 'override' || mode === 'assign';
+}
+
+function normalizeAssignModes(modes?: AssignMode[]): AssignMode[] {
+  const source = Array.isArray(modes) && modes.length ? modes : ALL_ASSIGN_MODES;
+  const out: AssignMode[] = [];
+  for (const mode of source) {
+    if (!isAssignMode(mode)) continue;
+    if (out.includes(mode)) continue;
+    out.push(mode);
+  }
+  return out.length ? out : ALL_ASSIGN_MODES;
+}
+
 export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (props) => {
   const {
     t,
@@ -118,6 +137,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     onChange,
     defaultMode = 'assign',
     fixedMode,
+    allowedModes: rawAllowedModes,
     showCondition = true,
     showEnable = true,
     showValueEditorWhenNoField = false,
@@ -129,6 +149,28 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
   } = props;
 
   const value = React.useMemo(() => (Array.isArray(rawValue) ? rawValue : []), [rawValue]);
+  const allowedModes = React.useMemo(
+    () => normalizeAssignModes(fixedMode ? [fixedMode] : rawAllowedModes),
+    [fixedMode, rawAllowedModes],
+  );
+  const getDefaultMode = React.useCallback((): AssignMode => {
+    if (fixedMode) return fixedMode;
+    if (isAssignMode(defaultMode) && allowedModes.includes(defaultMode)) return defaultMode;
+    return allowedModes[0] || 'assign';
+  }, [allowedModes, defaultMode, fixedMode]);
+  const normalizeItemMode = React.useCallback(
+    (item: FieldAssignRuleItem): FieldAssignRuleItem => {
+      const mode = isAssignMode(item?.mode) && allowedModes.includes(item.mode) ? item.mode : getDefaultMode();
+      return item?.mode === mode ? item : { ...item, mode };
+    },
+    [allowedModes, getDefaultMode],
+  );
+  const emitChange = React.useCallback(
+    (next: FieldAssignRuleItem[]) => {
+      onChange?.(next.map((item) => normalizeItemMode(item)));
+    },
+    [normalizeItemMode, onChange],
+  );
   const [cascaderOptions, setCascaderOptions] = React.useState<FieldAssignCascaderOption[]>(() =>
     Array.isArray(fieldOptions) ? (fieldOptions as FieldAssignCascaderOption[]) : [],
   );
@@ -312,7 +354,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
   const patchItem = (index: number, patch: Partial<FieldAssignRuleItem>) => {
     const next = value.map((it, i) => (i === index ? { ...it, ...patch } : it));
-    onChange?.(next);
+    emitChange(next);
   };
 
   const removeItem = (index: number) => {
@@ -334,7 +376,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
       setSyncingRuleKey(null);
     }
     const next = value.filter((_, i) => i !== index);
-    onChange?.(next);
+    emitChange(next);
   };
 
   const moveItem = (index: number, direction: 'up' | 'down') => {
@@ -343,7 +385,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     if (targetIndex < 0 || targetIndex >= next.length) return;
     const [item] = next.splice(index, 1);
     next.splice(targetIndex, 0, item);
-    onChange?.(next);
+    emitChange(next);
   };
 
   const addItem = () => {
@@ -352,29 +394,33 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
       {
         key: uid(),
         enable: true,
-        mode: fixedMode || defaultMode,
+        mode: getDefaultMode(),
         condition: { logic: '$and', items: [] },
         targetPath: undefined,
         value: undefined,
       },
     ];
-    onChange?.(next);
+    emitChange(next);
   };
 
   const getEffectiveMode = (item: FieldAssignRuleItem): AssignMode => {
     if (fixedMode) return fixedMode;
-    return item?.mode === 'default' ? 'default' : 'assign';
+    if (isAssignMode(item?.mode) && allowedModes.includes(item.mode)) return item.mode;
+    return getDefaultMode();
   };
 
   const renderAssignModeLabel = React.useCallback(
     (mode: AssignMode) => {
-      const modeText = mode === 'default' ? t('Default value') : t('Fixed value');
+      const modeText =
+        mode === 'default' ? t('Default value') : mode === 'override' ? t('Override value') : t('Fixed value');
       const modeHelpText =
         mode === 'default'
           ? t(
               'A pre-filled value. Editable, for new entries only, and won’t affect existing data (including empty values).',
             )
-          : t('A system-set value. Read-only.');
+          : mode === 'override'
+            ? t('Overrides existing values until the user edits it.')
+            : t('A system-set value. Read-only.');
 
       const preventModeToggle = (e: React.MouseEvent<HTMLElement>) => {
         e.preventDefault();
@@ -627,7 +673,8 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
   const renderPanelHeader = (item: FieldAssignRuleItem, index: number) => {
     const mode = getEffectiveMode(item);
-    const modeText = mode === 'default' ? t('Default value') : t('Fixed value');
+    const modeText =
+      mode === 'default' ? t('Default value') : mode === 'override' ? t('Override value') : t('Fixed value');
     const fieldLabel = getFieldLabel(item.targetPath);
     const title = fieldLabel ? String(fieldLabel) : t('Please select field');
 
@@ -935,8 +982,11 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
                 onChange={(event) => patchItem(index, { mode: event.target.value as AssignMode })}
               >
                 <Space size={16}>
-                  <Radio value="default">{renderAssignModeLabel('default')}</Radio>
-                  <Radio value="assign">{renderAssignModeLabel('assign')}</Radio>
+                  {allowedModes.map((allowedMode) => (
+                    <Radio key={allowedMode} value={allowedMode}>
+                      {renderAssignModeLabel(allowedMode)}
+                    </Radio>
+                  ))}
                 </Space>
               </Radio.Group>
             </div>

package/src/flow/components/__tests__/FieldAssignRulesEditor.test.tsx

@@ -795,15 +795,23 @@ describe('FieldAssignRulesEditor', () => {
     );
 
     expect(screen.getByLabelText('Default value')).toBeInTheDocument();
+    expect(screen.getByLabelText('Override value')).toBeInTheDocument();
     expect(screen.getByLabelText('Fixed value')).toBeInTheDocument();
     expect(screen.getByLabelText('Fixed value')).toBeChecked();
     await userEvent.click(screen.getByLabelText('Default value'));
     await waitFor(() => {
       expect(onChange).toHaveBeenCalled();
     });
-
-    const lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    let lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
     expect(lastCall?.[0]?.mode).toBe('default');
+
+    onChange.mockClear();
+    await userEvent.click(screen.getByLabelText('Override value'));
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalled();
+    });
+    lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    expect(lastCall?.[0]?.mode).toBe('override');
   });
 
   it('shows assignment mode tooltips for each option', async () => {
@@ -821,7 +829,7 @@ describe('FieldAssignRulesEditor', () => {
     );
 
     const questionIcons = Array.from(container.querySelectorAll('.anticon-question-circle'));
-    expect(questionIcons).toHaveLength(2);
+    expect(questionIcons).toHaveLength(3);
 
     await userEvent.hover(questionIcons[0] as Element);
     await waitFor(() => {
@@ -835,11 +843,80 @@ describe('FieldAssignRulesEditor', () => {
     await userEvent.unhover(questionIcons[0] as Element);
 
     await userEvent.hover(questionIcons[1] as Element);
+    await waitFor(() => {
+      expect(screen.getByText('Overrides existing values until the user edits it.')).toBeInTheDocument();
+    });
+
+    await userEvent.unhover(questionIcons[1] as Element);
+
+    await userEvent.hover(questionIcons[2] as Element);
     await waitFor(() => {
       expect(screen.getByText('A system-set value. Read-only.')).toBeInTheDocument();
     });
   });
 
+  it('honors allowed assignment modes', () => {
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: '1',
+        enable: true,
+        targetPath: 'title',
+        mode: 'override',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          value={value}
+          allowedModes={['default', 'assign']}
+          showCondition={false}
+          showEnable={false}
+        />,
+      ),
+    );
+
+    expect(screen.getByLabelText('Default value')).toBeInTheDocument();
+    expect(screen.getByLabelText('Fixed value')).toBeInTheDocument();
+    expect(screen.queryByLabelText('Override value')).toBeNull();
+    expect(screen.getByLabelText('Fixed value')).toBeChecked();
+  });
+
+  it('normalizes disallowed assignment mode before emitting changes', async () => {
+    const onChange = vi.fn();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: '1',
+        enable: true,
+        targetPath: 'title',
+        mode: 'override',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          value={value}
+          onChange={onChange}
+          allowedModes={['default', 'assign']}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await userEvent.click(screen.getByRole('switch'));
+
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalled();
+    });
+    const lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    expect(lastCall?.[0]?.mode).toBe('assign');
+  });
+
   it('merges extra item tree into base item while keeping order', () => {
     const base: MetaTreeNode[] = [
       { name: 'formValues', title: 'Current form', type: 'object', paths: ['formValues'] },
@@ -897,7 +974,7 @@ describe('FieldAssignRulesEditor', () => {
 
     const itemNode = merged.find((node) => node.name === 'item');
     expect(itemNode).toBeTruthy();
-    const parent = (itemNode.children as MetaTreeNode[]).find((node) => node.name === 'parentItem');
+    const parent = ((itemNode?.children as MetaTreeNode[]) || []).find((node) => node.name === 'parentItem');
     expect(parent).toBeTruthy();
 
     const nestedParent = ((parent?.children as MetaTreeNode[]) || []).find((node) => node.name === 'parentItem');