@nocobase/client-v2 2.1.0-beta.27 → 2.1.0-beta.30

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

@@ -159,12 +159,141 @@ describe('FormValueRuntime (default rules)', () => {
     await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
     await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
 
+    // change dependency again -> default keeps following while target is still the last default
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Z'));
+
     // user changes target -> default should be disabled permanently
     await runtime.setFormValues(fieldCtx, [{ path: ['a'], value: 'user' }], { source: 'user' });
-    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'W' }], { source: 'user' });
     expect(formStub.getFieldValue(['a'])).toBe('user');
   });
 
+  it('allows direct default patches to keep following until target is explicitly changed', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-1');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-2')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-2' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-2',
+      linkageTxId: 'tx-linkage-2',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-2');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-3' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-3')).toBe(true);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-4')).toBe(false);
+  });
+
+  it('keeps direct default patches active when an unchanged default value is carried by a row change', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roles: [{ uid: '1', title: '' }] });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-1',
+      linkageTxId: 'tx-linkage-row-1',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+    runtime.handleFormFieldsChange([{ name: ['roles', 0, 'title'], touched: true } as any]);
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    (runtime as any).markExplicit('roles');
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'uid'], '12');
+    runtime.handleFormValuesChange({ roles: formStub.getFieldValue(['roles']) }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '12' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-2',
+      linkageTxId: 'tx-linkage-row-2',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '12');
+    expect(formStub.getFieldValue(['roles', 0, 'title'])).toBe('12');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '13')).toBe(false);
+  });
+
+  it('does not mark omitted sibling fields from partial top-level changedValues as explicit', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ __is_new__: true, __index__: 'row-1', name: '1', title: '1' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-partial-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'name'], '12');
+    runtime.handleFormValuesChange({ roles: [{ name: '12' }] }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+  });
+
   it('handles onFieldsChange name as string and triggers default recompute', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
@@ -3267,4 +3396,41 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(payload.txId).toBe('tx-current');
     expect(payload.linkageTxId).toBe('tx-root');
   });
+
+  it('does not mark linkage writes explicit so later user edits can keep following default linkage', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-linkage-linkage-not-explicit',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+      linkageScopeDepth: 0,
+    });
+
+    expect(formStub.getFieldValue(['roleName'])).toBe('role-uid-1');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], {
+      source: 'user',
+      txId: 'tx-user-1',
+    });
+    expect(formStub.getFieldValue(['roleUid'])).toBe('role-uid-2');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+  });
 });

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

@@ -137,6 +137,42 @@ export class FormValueRuntime {
     return this.getForm().getFieldsValue(true);
   }
 
+  canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
+    if (!namePath?.length) return false;
+    if (typeof resolved === 'undefined') return false;
+
+    const pathKey = namePathToPathKey(namePath);
+    const current = this.getFormValueAtPath(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    const nextSnapshot = isObservable(resolved) ? toJS(resolved) : resolved;
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    const currentEqualsLastDefault = typeof last !== 'undefined' && _.isEqual(currentSnapshot, last);
+    const explicitHit = this.findExplicitHit(pathKey);
+
+    if (explicitHit && !currentEqualsLastDefault) return false;
+
+    const canOverwrite = isEmptyValue(current) || currentEqualsLastDefault;
+    if (!canOverwrite && _.isEqual(current, nextSnapshot)) {
+      this.lastDefaultValueByPathKey.set(pathKey, nextSnapshot);
+      return false;
+    }
+
+    return canOverwrite;
+  }
+
+  recordDefaultValuePatch(namePath: NamePath, value?: any) {
+    if (!namePath?.length) return;
+    const pathKey = namePathToPathKey(namePath);
+    const snapshot =
+      arguments.length >= 2 ? (isObservable(value) ? toJS(value) : value) : this.getFormValueAtPath(namePath);
+    this.lastDefaultValueByPathKey.set(pathKey, snapshot);
+    const current = this.getFormValueAtPath(namePath);
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    if (_.isEqual(currentSnapshot, snapshot)) {
+      this.clearExplicitForDefaultPatch(pathKey);
+    }
+  }
+
   private getFormValueAtPath(namePath: NamePath) {
     const form: any = this.getForm?.();
     if (form && typeof form.getFieldValue === 'function') {
@@ -247,11 +283,7 @@ export class FormValueRuntime {
     let bumpedWriteSeq = false;
     for (const field of changedFields || []) {
       const name = field?.name;
-      const namePath: NamePath | null = Array.isArray(name)
-        ? (name as NamePath)
-        : typeof name === 'string' || typeof name === 'number'
-          ? ([name] as NamePath)
-          : null;
+      const namePath = this.normalizeObservedNamePath(name);
       if (!namePath?.length) continue;
       const nextValue = form.getFieldValue(namePath as any);
       const prevValue = _.get(this.valuesMirror, namePath);
@@ -265,8 +297,11 @@ export class FormValueRuntime {
       const isMeaningfulTouched =
         field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
       if (isMeaningfulTouched) {
-        touchedChangedPathKeys.add(namePathToPathKey(namePath));
-        hasMeaningfulTouchedChange = true;
+        const pathKey = namePathToPathKey(namePath);
+        if (!this.shouldKeepDefaultPathValueEnabled(namePath, nextValue)) {
+          touchedChangedPathKeys.add(pathKey);
+          hasMeaningfulTouchedChange = true;
+        }
       }
     }
 
@@ -526,6 +561,10 @@ export class FormValueRuntime {
   }
 
   private getObservedChangedValue(path: NamePath, changedValues: any, snapshot: any) {
+    if (_.has(snapshot, path as any)) {
+      return _.get(snapshot, path as any);
+    }
+
     if (path?.length === 1) {
       const key = path[0];
       if (
@@ -546,6 +585,7 @@ export class FormValueRuntime {
 
     let observed = snapshot;
     for (const key of Object.keys(changedValues)) {
+      if (_.has(observed, [key])) continue;
       if (observed === snapshot) {
         observed = Array.isArray(snapshot) ? [...snapshot] : { ...snapshot };
       }
@@ -573,7 +613,15 @@ export class FormValueRuntime {
     this.lastObservedChangedPaths = null;
     this.lastObservedSource = null;
 
-    const rawSnapshot = allValues && typeof allValues === 'object' ? allValues : this.getFormValuesSnapshot();
+    // 子表格的 changedValues 可能只包含局部行对象，diff 必须以 form 当前完整快照为准，
+    // 否则缺失的 sibling 字段会被误判为用户清空。
+    const formSnapshot = this.getFormValuesSnapshot();
+    const rawSnapshot =
+      formSnapshot && typeof formSnapshot === 'object'
+        ? formSnapshot
+        : allValues && typeof allValues === 'object'
+          ? allValues
+          : changedValues;
     const snapshot = this.getObservedSnapshot(changedValues, rawSnapshot);
     this.reconcileArrayItemState([...rawChangedPaths, ...changedValuePaths], changedValues, snapshot);
     this.pruneDeletedArrayItemState(snapshot);
@@ -602,8 +650,16 @@ export class FormValueRuntime {
       this.bumpChangeTick();
     }
 
-    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    const explicitPathsToMark: NamePath[] = [];
     for (const p of explicitPaths) {
+      if (this.shouldKeepDefaultPathEnabled(p, snapshot)) {
+        continue;
+      }
+      explicitPathsToMark.push(p);
+    }
+
+    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    for (const p of explicitPathsToMark) {
       this.markExplicit(namePathToPathKey(p));
     }
 
@@ -733,7 +789,7 @@ export class FormValueRuntime {
     const source: ValueSource = options?.source ?? 'system';
     const triggerEvent = options?.triggerEvent !== false;
     const txId = options?.txId ?? createTxId();
-    const markExplicit = options?.markExplicit ?? source !== 'default';
+    const markExplicit = options?.markExplicit ?? (source !== 'default' && source !== 'linkage');
     const ownsTxId = typeof options?.txId === 'undefined';
 
     const linkageScopeDepth =
@@ -1071,10 +1127,12 @@ export class FormValueRuntime {
   private markExplicit(pathKey: string) {
     if (this.explicitSet.has(pathKey)) return;
     this.explicitSet.add(pathKey);
+    const preserveDescendantDefaults = this.shouldPreserveDescendantDefaultsOnExplicit(pathKey);
 
     // explicit 后默认值永远失效：清理该路径及其子路径的 lastDefault 记录，避免误判“仍是默认值”
     for (const k of Array.from(this.lastDefaultValueByPathKey.keys())) {
-      if (k === pathKey || k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`)) {
+      const isDescendant = k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`);
+      if (k === pathKey || (!preserveDescendantDefaults && isDescendant)) {
         this.lastDefaultValueByPathKey.delete(k);
       }
     }
@@ -1087,6 +1145,40 @@ export class FormValueRuntime {
     }
   }
 
+  private normalizeObservedNamePath(name: NamePath | string | number | undefined): NamePath | null {
+    if (Array.isArray(name)) return name as NamePath;
+    if (typeof name === 'number') return [name];
+    if (typeof name !== 'string' || !name) return null;
+    const parsed = pathKeyToNamePath(name);
+    return parsed.length ? parsed : [name];
+  }
+
+  private clearExplicitForDefaultPatch(pathKey: string) {
+    for (const key of Array.from(this.explicitSet)) {
+      if (key === pathKey || key.startsWith(`${pathKey}.`) || key.startsWith(`${pathKey}[`)) {
+        this.explicitSet.delete(key);
+      }
+    }
+  }
+
+  private shouldPreserveDescendantDefaultsOnExplicit(pathKey: string) {
+    const value = this.getFormValueAtPath(pathKeyToNamePath(pathKey));
+    return Array.isArray(value);
+  }
+
+  private shouldKeepDefaultPathEnabled(namePath: NamePath, snapshot: any) {
+    return this.shouldKeepDefaultPathValueEnabled(namePath, _.get(snapshot, namePath as any));
+  }
+
+  private shouldKeepDefaultPathValueEnabled(namePath: NamePath, value: any) {
+    const pathKey = namePathToPathKey(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    if (typeof last === 'undefined') return false;
+
+    const nextSnapshot = isObservable(value) ? toJS(value) : value;
+    return _.isEqual(nextSnapshot, last);
+  }
+
   private isExplicit(pathKey: string) {
     return !!this.findExplicitHit(pathKey);
   }

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/PopupSubTableFieldModel.tsx

@@ -30,6 +30,7 @@ import { useTranslation } from 'react-i18next';
 import { buildRecordPickerPopupContextInputArgs, RecordPickerContent } from '../RecordPickerFieldModel';
 import { AssociationFieldModel } from '../AssociationFieldModel';
 import { adjustColumnOrder } from '../../../blocks/table/utils';
+import { isSubTableColumnFieldComponentContext } from '../SubTableFieldModel/SubTableColumnModel';
 import { EditFormContent } from './actions/PopupSubTableEditActionModel';
 import { QuickEditFormModel } from '../../../blocks/form/QuickEditFormModel';
 import { ActionWithoutPermission } from '../../../base/ActionModel';
@@ -901,6 +902,9 @@ PopupSubTableFieldModel.define({
 EditableItemModel.bindModelToInterface('PopupSubTableFieldModel', ['m2m', 'o2m', 'mbm'], {
   order: 300,
   when: (ctx, field) => {
+    if (isSubTableColumnFieldComponentContext(ctx)) {
+      return false;
+    }
     if (field.targetCollection) {
       return field.targetCollection.template !== 'file';
     }

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -36,6 +36,12 @@ import { FieldDeletePlaceholder, CustomWidth } from '../../../blocks/table/Table
 import { buildDynamicNamePath } from '../../../blocks/form/dynamicNamePath';
 import { getSubTableRowIdentity } from './rowIdentity';
 
+export const SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT = 'subTableColumn';
+
+export function isSubTableColumnFieldComponentContext(ctx) {
+  return (ctx?.model?.constructor as any)?.fieldComponentContext === SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT;
+}
+
 const SubTableRowRuleBinder: React.FC<{ model: any }> = ({ model }) => {
   React.useEffect(() => {
     const emitter = model?.flowEngine?.emitter;
@@ -177,6 +183,25 @@ const MemoFieldRenderer = React.memo(FieldModelRenderer, (prev, next) => {
   return prev.value === next.value && prev.model === next.model;
 });
 
+export function buildRowPathFromFieldIndex(fieldIndex: unknown): Array<string | number> | null {
+  if (!Array.isArray(fieldIndex) || !fieldIndex.length) return null;
+  const out: Array<string | number> = [];
+  for (const entry of fieldIndex) {
+    if (typeof entry !== 'string') continue;
+    const [fieldName, indexStr] = entry.split(':');
+    const index = Number(indexStr);
+    if (!fieldName || !Number.isFinite(index)) continue;
+    out.push(fieldName, index);
+  }
+  return out.length ? out : null;
+}
+
+export function getLatestSubTableRowRecord(form: any, fieldIndex: unknown, fallbackRecord: any): any {
+  const latestRowPath = buildRowPathFromFieldIndex(fieldIndex);
+  const latestRecord = latestRowPath ? form?.getFieldValue?.(latestRowPath) : undefined;
+  return typeof latestRecord === 'undefined' ? fallbackRecord : latestRecord;
+}
+
 function shouldCommitImmediately(value: any) {
   if (Array.isArray(value)) {
     return true;
@@ -382,6 +407,7 @@ export class SubTableColumnModel<
   T extends SubTableColumnModelStructure = SubTableColumnModelStructure,
 > extends EditableItemModel<T> {
   static renderMode = ModelRenderMode.RenderFunction;
+  static fieldComponentContext = SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT;
 
   renderHiddenInConfig() {
     return <FieldWithoutPermissionPlaceholder targetModel={this} />;
@@ -574,6 +600,9 @@ export class SubTableColumnModel<
       const rowForkKey = `row:${baseIndexKey}:${rowIdentity}:${String(rowIdx)}`;
       const rowFork: any = (() => {
         const fork = this.createFork({}, rowForkKey);
+        fork.context.defineProperty('subTableRowFork', {
+          value: true,
+        });
         const associationFieldPath =
           (this.parent as any)?.fieldPath ??
           (this.parent as any)?.context?.fieldPath ??
@@ -592,9 +621,11 @@ export class SubTableColumnModel<
         }
         fork.context.defineProperty('item', {
           get: () => {
+            const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
+            const rowRecord = getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
             const parentItemCtx = (parentItem ?? this.context?.item) as any;
-            const isNew = record?.__is_new__;
-            const isStored = record?.__is_stored__;
+            const isNew = rowRecord?.__is_new__;
+            const isStored = rowRecord?.__is_stored__;
             const list = (this.parent as any)?.props?.value;
             const length = Array.isArray(list) ? list.length : undefined;
             return {
@@ -602,7 +633,7 @@ export class SubTableColumnModel<
               length,
               __is_new__: isNew,
               __is_stored__: isStored,
-              value: record,
+              value: rowRecord,
               parentItem: parentItemCtx,
             };
           },

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableField.tsx

@@ -14,8 +14,41 @@ import { useTranslation } from 'react-i18next';
 import { PlusOutlined } from '@ant-design/icons';
 import React, { useEffect, useMemo, useState } from 'react';
 import { ActionWithoutPermission } from '../../../base/ActionModel';
+import { parsePathString } from '../../../blocks/form/value-runtime/path';
 import { getSubTableRowIdentity, normalizeSubTableRows } from './rowIdentity';
 
+type NamePath = Array<string | number>;
+
+function isSamePathPrefix(prefix: NamePath, path: NamePath) {
+  if (!prefix.length || prefix.length > path.length) return false;
+  return prefix.every((seg, index) => seg === path[index]);
+}
+
+function isRelatedPath(a: NamePath, b: NamePath) {
+  return isSamePathPrefix(a, b) || isSamePathPrefix(b, a);
+}
+
+function normalizeChangedPath(path: unknown): NamePath | null {
+  const rawPath = Array.isArray(path) ? path : typeof path === 'string' ? [path] : null;
+  if (!rawPath) return null;
+  const normalized = rawPath.flatMap((seg) => {
+    if (typeof seg === 'number') return [seg];
+    if (typeof seg !== 'string') return [];
+    return parsePathString(seg).filter((parsed): parsed is string | number => typeof parsed !== 'object');
+  });
+  return normalized.length ? normalized : null;
+}
+
+function shouldRefreshForChangedPaths(fieldPath: unknown, changedPaths: unknown) {
+  const currentFieldPath = normalizeChangedPath(fieldPath);
+  if (!currentFieldPath) return false;
+  const paths = Array.isArray(changedPaths) ? changedPaths : [];
+  return paths.some((path) => {
+    const changedPath = normalizeChangedPath(path);
+    return changedPath ? isRelatedPath(currentFieldPath, changedPath) : false;
+  });
+}
+
 export function SubTableField(props) {
   const { t } = useTranslation();
   const {
@@ -35,9 +68,12 @@ export function SubTableField(props) {
     resetPage,
     filterTargetKey = 'id',
     getCurrentValue,
+    fieldPathArray,
+    formValuesChangeEmitter,
   } = props;
   const [currentPage, setCurrentPage] = useState(1);
   const [currentPageSize, setCurrentPageSize] = useState(pageSize);
+  const [, forceRefresh] = useState(0);
   const rawCurrentValue = getCurrentValue();
   const currentValue = useMemo(() => normalizeSubTableRows(rawCurrentValue), [rawCurrentValue]);
   const getRecordIdentity = React.useCallback(
@@ -50,6 +86,17 @@ export function SubTableField(props) {
   useEffect(() => {
     resetPage && setCurrentPage(1);
   }, [resetPage]);
+  useEffect(() => {
+    if (!formValuesChangeEmitter?.on || !formValuesChangeEmitter?.off) return;
+    const listener = (payload: any) => {
+      if (!shouldRefreshForChangedPaths(fieldPathArray, payload?.changedPaths)) return;
+      forceRefresh((v) => v + 1);
+    };
+    formValuesChangeEmitter.on('formValuesChange', listener);
+    return () => {
+      formValuesChangeEmitter.off('formValuesChange', listener);
+    };
+  }, [fieldPathArray, formValuesChangeEmitter]);
   const applyValue = React.useCallback((nextValue: any) => onChange?.(normalizeSubTableRows(nextValue)), [onChange]);
   const getLatestValue = React.useCallback(() => normalizeSubTableRows(getCurrentValue()), [getCurrentValue]);
   useEffect(() => {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableColumnModel.rowRecord.test.ts

@@ -0,0 +1,42 @@
+/**
+ * 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, vi } from 'vitest';
+import { getLatestSubTableRowRecord, buildRowPathFromFieldIndex } from '../SubTableColumnModel';
+
+describe('SubTableColumnModel row record helpers', () => {
+  it('builds the row path from fieldIndex entries', () => {
+    expect(buildRowPathFromFieldIndex(['roles:0'])).toEqual(['roles', 0]);
+    expect(buildRowPathFromFieldIndex(['users:1', 'roles:2'])).toEqual(['users', 1, 'roles', 2]);
+  });
+
+  it('prefers the latest row value from form over the fallback record', () => {
+    const form = {
+      getFieldValue: vi.fn((path: any) => {
+        if (JSON.stringify(path) === JSON.stringify(['roles', 0])) {
+          return { uid: 'role-uid-1', __is_new__: true };
+        }
+      }),
+    };
+    const fallback = { uid: 'stale-role', __is_new__: false };
+
+    expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toEqual({
+      uid: 'role-uid-1',
+      __is_new__: true,
+    });
+    expect(form.getFieldValue).toHaveBeenCalledWith(['roles', 0]);
+  });
+
+  it('falls back to the record when latest row value is unavailable', () => {
+    const form = { getFieldValue: vi.fn(() => undefined) };
+    const fallback = { uid: 'stale-role', __is_new__: false };
+
+    expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toBe(fallback);
+  });
+});