@nocobase/client-v2 2.1.0-beta.21 → 2.1.0-beta.23

package/src/flow/models/blocks/form/__tests__/QuickEditFormModel.quickEdit.test.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 { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FlowEngine, SingleRecordResource } from '@nocobase/flow-engine';
+import { QuickEditFormModel } from '../QuickEditFormModel';
+
+describe('QuickEditFormModel - quick edit save triggers API (regression)', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+  });
+
+  it('calls update with filterByTk and merges primary key from ctx.collection/record', async () => {
+    // 1) 准备数据源与集合（含主键字段）
+    const dsm = engine.context.dataSourceManager;
+    const ds = dsm.getDataSource('main');
+    ds.addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'name', type: 'string', interface: 'text' },
+      ],
+    });
+
+    // 2) 注入 API mock：拦截请求并断言参数
+    const api = {
+      request: vi.fn(async (config: any) => {
+        expect(config.method).toBe('post');
+        expect(config.url).toBe('users:update');
+        // filterByTk 通过 params 传入
+        expect(config.params?.filterByTk).toBe(1);
+        // data 应包含要更新的字段以及主键（由 ctx.collection + ctx.record 推导）
+        expect(config.data).toMatchObject({ name: 'new-name' });
+        return { data: { data: {} } } as any;
+      }),
+    } as any;
+    engine.context.defineProperty('api', { value: api });
+
+    // 3) 创建 QuickEditFormModel；onInit 中已为 ctx 注入 collection getter（本次回归修复点）
+    const m = engine.createModel<QuickEditFormModel>({
+      use: QuickEditFormModel,
+      uid: 'qe-1',
+    });
+
+    (m as any).collection = dsm.getCollection('main', 'users');
+    const res = m.context.createResource(SingleRecordResource) as SingleRecordResource<any>;
+    res.setDataSourceKey('main');
+    res.setResourceName('users');
+    (m as any).resource = res;
+
+    // 预置当前记录（ctx.record 由 QuickEditFormModel.onInit 提供）与 tk
+    res.setFilterByTk(1);
+    res.setData({ name: 'old-name' });
+
+    // 4) 保存：应触发 update 请求，并包含主键
+    await res.save({ name: 'new-name' }, { refresh: false });
+
+    expect(api.request).toHaveBeenCalledTimes(1);
+  });
+});

package/src/flow/models/blocks/form/__tests__/assignRulesUpdateAssociationValues.test.ts

@@ -0,0 +1,81 @@
+/**
+ * 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 { collectUpdateAssociationValuesFromAssignRules } from '../assignRulesUpdateAssociationValues';
+
+describe('collectUpdateAssociationValuesFromAssignRules', () => {
+  it('collects deepest association path from targetPath', () => {
+    const profileCollection: any = {
+      getField: (name: string) => ({ name, isAssociationField: () => false }),
+    };
+
+    const userCollection: any = {
+      getField: (name: string) => {
+        if (name === 'profile') {
+          return { name, isAssociationField: () => true, targetCollection: profileCollection };
+        }
+        return { name, isAssociationField: () => false };
+      },
+    };
+
+    const rootCollection: any = {
+      getField: (name: string) => {
+        if (name === 'user') {
+          return { name, isAssociationField: () => true, targetCollection: userCollection };
+        }
+        if (name === 'users') {
+          return { name, isAssociationField: () => true, targetCollection: userCollection };
+        }
+        return { name, isAssociationField: () => false };
+      },
+    };
+
+    const items = [
+      { targetPath: 'title' },
+      { targetPath: 'user.name' },
+      { targetPath: 'user.profile.name' },
+      { targetPath: 'users.nickname' },
+    ];
+
+    const out = collectUpdateAssociationValuesFromAssignRules(items as any, rootCollection);
+    expect(out).toEqual(expect.arrayContaining(['user', 'user.profile', 'users']));
+  });
+
+  it('returns [] when targetPath does not traverse associations', () => {
+    const rootCollection: any = {
+      getField: (name: string) => ({ name, isAssociationField: () => false }),
+    };
+
+    const out = collectUpdateAssociationValuesFromAssignRules(
+      [{ targetPath: 'jsonField.name' }] as any,
+      rootCollection,
+    );
+    expect(out).toEqual([]);
+  });
+
+  it('ignores association targetKey-only paths (e.g. user.id)', () => {
+    const userCollection: any = {
+      getField: (name: string) => ({ name, isAssociationField: () => false }),
+      filterTargetKey: 'id',
+    };
+
+    const rootCollection: any = {
+      getField: (name: string) => {
+        if (name === 'user') {
+          return { name, isAssociationField: () => true, targetCollection: userCollection };
+        }
+        return { name, isAssociationField: () => false };
+      },
+    };
+
+    const out = collectUpdateAssociationValuesFromAssignRules([{ targetPath: 'user.id' }] as any, rootCollection);
+    expect(out).toEqual([]);
+  });
+});

package/src/flow/models/blocks/form/__tests__/dynamicNamePath.test.ts

@@ -0,0 +1,33 @@
+/**
+ * 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, it, expect } from 'vitest';
+import { buildDynamicNamePath } from '../dynamicNamePath';
+
+describe('buildDynamicNamePath', () => {
+  it('returns nameParts when no fieldIndex', () => {
+    expect(buildDynamicNamePath(['a', 'b'])).toEqual(['a', 'b']);
+  });
+
+  it('maps list field to row index (simple)', () => {
+    expect(buildDynamicNamePath(['orders', 'amount'], ['orders:2'])).toEqual([2, 'amount']);
+  });
+
+  it('handles same-name nested list field (outer list -> keep inner field name)', () => {
+    expect(buildDynamicNamePath(['products', 'products'], ['products:0'])).toEqual([0, 'products']);
+  });
+
+  it('handles same-name nested list field (inner list -> skip inner field name)', () => {
+    expect(buildDynamicNamePath(['products', 'products', 'id'], ['products:1', 'products:0'])).toEqual([0, 'id']);
+  });
+
+  it('falls back to last occurrence when occurrences mismatch', () => {
+    expect(buildDynamicNamePath(['products', 'id'], ['products:0', 'products:1'])).toEqual([1, 'id']);
+  });
+});

package/src/flow/models/blocks/form/__tests__/legacyDefaultValueMigration.test.ts

@@ -0,0 +1,135 @@
+/**
+ * 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 {
+  clearLegacyDefaultValuesFromFormModel,
+  collectLegacyDefaultValueRulesFromFormModel,
+  mergeAssignRulesWithLegacyDefaults,
+} from '../legacyDefaultValueMigration';
+
+function createMockFieldModel(options: { uid: string; props?: Record<string, any>; stepParams?: Record<string, any> }) {
+  const model: any = {
+    uid: options.uid,
+    props: { ...(options.props || {}) },
+    stepParams: { ...(options.stepParams || {}) },
+    emitter: { emit: vi.fn() },
+    setProps(patch: any) {
+      this.props = { ...(this.props || {}), ...(patch || {}) };
+    },
+    getProps() {
+      return this.props;
+    },
+    getStepParams(flowKey: string, stepKey: string) {
+      return this.stepParams?.[flowKey]?.[stepKey];
+    },
+  };
+  return model;
+}
+
+describe('legacyDefaultValueMigration', () => {
+  it('collects legacy field initialValue into form-level default rules', () => {
+    const field1 = createMockFieldModel({
+      uid: 'f1',
+      props: { initialValue: 'a' },
+      stepParams: {
+        fieldSettings: { init: { fieldPath: 'f1' } },
+        editItemSettings: { initialValue: { defaultValue: 'a' } },
+      },
+    });
+    const field2 = createMockFieldModel({
+      uid: 'f2',
+      stepParams: {
+        fieldSettings: { init: { fieldPath: 'f2' } },
+        editItemSettings: { initialValue: { defaultValue: 'b' } },
+      },
+    });
+    const field3 = createMockFieldModel({
+      uid: 'f3',
+      stepParams: {
+        fieldSettings: { init: { fieldPath: 'f3' } },
+        formItemSettings: { initialValue: { defaultValue: 'c' } },
+      },
+    });
+    const field4 = createMockFieldModel({ uid: 'f4', props: { other: 1 } });
+
+    const formModel: any = { subModels: { grid: { subModels: { items: [field1, field2, field3, field4] } } } };
+
+    const rules = collectLegacyDefaultValueRulesFromFormModel(formModel);
+    expect(rules).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ targetPath: 'f1', mode: 'default', value: 'a' }),
+        expect.objectContaining({ targetPath: 'f2', mode: 'default', value: 'b' }),
+        expect.objectContaining({ targetPath: 'f3', mode: 'default', value: 'c' }),
+      ]),
+    );
+    expect(rules.find((r: any) => r.targetPath === 'f4')).toBeUndefined();
+  });
+
+  it('merges legacy defaults without duplicating existing default rules', () => {
+    const legacy = [
+      { key: 'legacy-default:f1', targetPath: 'f1', mode: 'default', value: 1 },
+      { key: 'legacy-default:f2', targetPath: 'f2', mode: 'default', value: 2 },
+    ] as any[];
+
+    const existing = [
+      { key: 'k-1', targetPath: 'f2', mode: 'default', value: 999 },
+      { key: 'k-2', targetPath: 'f3', mode: 'assign', value: 'x' },
+    ] as any[];
+
+    const merged = mergeAssignRulesWithLegacyDefaults(existing as any, legacy as any);
+    // f2 already has default rule -> legacy f2 should not be appended
+    expect(merged.find((r: any) => r.targetPath === 'f2' && r.mode === 'default')?.value).toBe(999);
+    // f1 should be appended
+    expect(merged.some((r: any) => r.targetPath === 'f1' && r.mode === 'default' && r.value === 1)).toBe(true);
+  });
+
+  it('does not re-append legacy defaults if already migrated (legacy key) even when mode was coerced', () => {
+    const legacy = [{ key: 'legacy-default:f1', targetPath: 'f1', mode: 'default', value: 1 }] as any[];
+
+    const existing = [{ key: 'legacy-default:f1', targetPath: 'f1', mode: 'assign', value: 1 }] as any[];
+    const merged = mergeAssignRulesWithLegacyDefaults(existing as any, legacy as any);
+    expect(merged).toHaveLength(1);
+    expect(merged[0]).toMatchObject({ key: 'legacy-default:f1', targetPath: 'f1' });
+
+    const existingWithModifiedKey = [
+      { key: 'legacy-default:f1:f1', targetPath: 'f1', mode: 'assign', value: 1 },
+    ] as any[];
+    const merged2 = mergeAssignRulesWithLegacyDefaults(existingWithModifiedKey as any, legacy as any);
+    expect(merged2).toHaveLength(1);
+    expect(merged2[0]).toMatchObject({ key: 'legacy-default:f1:f1', targetPath: 'f1' });
+  });
+
+  it('clears field-level initialValue configs from form model items', () => {
+    const field1 = createMockFieldModel({
+      uid: 'f1',
+      props: { initialValue: 'a', keep: true },
+      stepParams: { editItemSettings: { initialValue: { defaultValue: 'a' } }, otherFlow: { s: { x: 1 } } },
+    });
+    const field2 = createMockFieldModel({
+      uid: 'f2',
+      stepParams: { formItemSettings: { initialValue: { defaultValue: 'b' } } },
+    });
+    const field3 = createMockFieldModel({ uid: 'f3', props: { keep: 1 } });
+
+    const formModel: any = { subModels: { grid: { subModels: { items: [field1, field2, field3] } } } };
+
+    clearLegacyDefaultValuesFromFormModel(formModel);
+
+    // field1: props.initialValue removed, stepParams cleared for initialValue
+    expect(field1.props.initialValue).toBeUndefined();
+    expect(field1.props.keep).toBe(true);
+    expect(field1.stepParams.editItemSettings?.initialValue).toBeUndefined();
+    expect(field1.stepParams.otherFlow?.s?.x).toBe(1);
+    // field2: legacy flow cleared
+    expect(field2.stepParams.formItemSettings?.initialValue).toBeUndefined();
+    // field3 unaffected
+    expect(field3.props.keep).toBe(1);
+  });
+});

package/src/flow/models/blocks/form/__tests__/submitValues.test.ts

@@ -0,0 +1,224 @@
+/**
+ * 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, it, expect } from 'vitest';
+import { FlowEngine, FlowModel, SingleRecordResource } from '@nocobase/flow-engine';
+// 直接从 models 聚合导入，避免局部文件相互引用顺序导致的循环依赖
+import { FormBlockModel } from '../../../..';
+import {
+  getValidationNamePathsExcludingHiddenModels,
+  omitHiddenModelValuesFromSubmit,
+  shouldSkipSubmitValidation,
+  validateSubmitForm,
+} from '../submitValues';
+
+class TestFormModel extends FormBlockModel {
+  createResource(ctx: any, _params: any) {
+    return ctx.createResource(SingleRecordResource);
+  }
+
+  renderComponent() {
+    return null;
+  }
+}
+
+function createEngine() {
+  const engine = new FlowEngine();
+  engine.registerModels({ TestFormModel });
+  return engine;
+}
+
+function createFormBlock(engine: FlowEngine, uid: string) {
+  return engine.createModel<TestFormModel>({
+    use: 'TestFormModel',
+    uid,
+    stepParams: {
+      resourceSettings: {
+        init: { dataSourceKey: 'main', collectionName: 'orders' },
+      },
+    },
+  });
+}
+
+function createFieldModel(
+  engine: FlowEngine,
+  uid: string,
+  parent: FlowModel,
+  options?: {
+    hidden?: boolean;
+    fieldPathArray?: Array<string | number>;
+    stepFieldPath?: string;
+    props?: Record<string, any>;
+  },
+) {
+  const model = engine.createModel<FlowModel>({
+    use: 'FlowModel',
+    uid,
+    parentId: parent.uid,
+    stepParams: options?.stepFieldPath
+      ? {
+          fieldSettings: {
+            init: { fieldPath: options.stepFieldPath },
+          },
+        }
+      : undefined,
+  });
+
+  if (options?.fieldPathArray) {
+    model.context.defineProperty('fieldPathArray', { value: options.fieldPathArray });
+  }
+  if (options?.props && typeof options.props === 'object') {
+    model.setProps(options.props);
+  }
+  if (typeof options?.hidden === 'boolean') {
+    model.hidden = options.hidden;
+  }
+
+  return model;
+}
+
+describe('omitHiddenModelValuesFromSubmit', () => {
+  it('removes values for hidden fields in the same block', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-b', blockModel, { hidden: true, fieldPathArray: ['b'] });
+
+    expect(omitHiddenModelValuesFromSubmit({ a: 1, b: 2 }, blockModel)).toEqual({ a: 1 });
+  });
+
+  it('does not remove values when model.hidden is false (Hidden (reserved value) semantics)', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-b', blockModel, { hidden: false, fieldPathArray: ['b'], props: { hidden: true } });
+
+    expect(omitHiddenModelValuesFromSubmit({ a: 1, b: 2 }, blockModel)).toEqual({ a: 1, b: 2 });
+  });
+
+  it('resolves fork row index via fieldIndex and removes only the targeted row field', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    const master = createFieldModel(engine, 'field-list', blockModel, { stepFieldPath: 'list.x', hidden: false });
+    const fork: any = master.createFork({}, 'row-0');
+    fork.hidden = true;
+    fork.context.defineProperty('fieldIndex', { value: ['list:0'] });
+
+    expect(omitHiddenModelValuesFromSubmit({ list: [{ x: 1, y: 2 }] }, blockModel)).toEqual({ list: [{ y: 2 }] });
+  });
+
+  it('does not remove values for hidden models belonging to other blocks', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    const otherBlockModel = createFormBlock(engine, 'block-2');
+    createFieldModel(engine, 'field-b2', otherBlockModel, { hidden: true, fieldPathArray: ['b'] });
+
+    expect(omitHiddenModelValuesFromSubmit({ a: 1, b: 2 }, blockModel)).toEqual({ a: 1, b: 2 });
+  });
+
+  it('cleans up empty plain-object ancestors (but keeps arrays intact)', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-ab', blockModel, { hidden: true, stepFieldPath: 'a.b' });
+
+    expect(omitHiddenModelValuesFromSubmit({ a: { b: 1 } }, blockModel)).toEqual({});
+  });
+});
+
+describe('getValidationNamePathsExcludingHiddenModels', () => {
+  it('excludes hidden field paths from validation name list', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-b', blockModel, { hidden: true, fieldPathArray: ['b'] });
+    (blockModel.context as any).defineProperty('form', {
+      value: {
+        getFieldsError: () => [{ name: ['a'] }, { name: ['b'] }],
+      },
+    });
+
+    expect(getValidationNamePathsExcludingHiddenModels(blockModel)).toEqual([['a']]);
+  });
+
+  it('keeps validation names when field uses hidden reserved value semantics', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-b', blockModel, { hidden: false, fieldPathArray: ['b'], props: { hidden: true } });
+    (blockModel.context as any).defineProperty('form', {
+      value: {
+        getFieldsError: () => [{ name: ['a'] }, { name: ['b'] }],
+      },
+    });
+
+    expect(getValidationNamePathsExcludingHiddenModels(blockModel)).toEqual([['a'], ['b']]);
+  });
+
+  it('returns null when no registered field names are available', () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    (blockModel.context as any).defineProperty('form', {
+      value: {
+        getFieldsError: () => [],
+      },
+    });
+
+    expect(getValidationNamePathsExcludingHiddenModels(blockModel)).toBeNull();
+  });
+});
+
+describe('submit validation helpers', () => {
+  it('detects skip validation switch from submitSettings', () => {
+    expect(
+      shouldSkipSubmitValidation({
+        getStepParams: (flowKey: string, stepKey: string) => {
+          if (flowKey === 'submitSettings' && stepKey === 'skipRequiredValidation') {
+            return { skipValidator: true };
+          }
+        },
+      }),
+    ).toBe(true);
+
+    expect(
+      shouldSkipSubmitValidation({
+        getStepParams: () => ({ skipValidator: false }),
+      }),
+    ).toBe(false);
+  });
+
+  it('skips validateFields completely when skipValidator is enabled', async () => {
+    const validateFields = vi.fn(async () => undefined);
+
+    await validateSubmitForm({
+      form: { validateFields },
+      skipValidator: true,
+    });
+
+    expect(validateFields).not.toHaveBeenCalled();
+  });
+
+  it('validates only visible name paths in flow settings mode', async () => {
+    const engine = createEngine();
+    const blockModel = createFormBlock(engine, 'block-1');
+    createFieldModel(engine, 'field-hidden', blockModel, { hidden: true, fieldPathArray: ['b'] });
+
+    const validateFields = vi.fn(async () => undefined);
+    (blockModel.context as any).defineProperty('form', {
+      value: {
+        validateFields,
+        getFieldsError: () => [{ name: ['a'] }, { name: ['b'] }],
+      },
+    });
+
+    await validateSubmitForm({
+      form: blockModel.form as any,
+      blockModel,
+      flowSettingsEnabled: true,
+      skipValidator: false,
+    });
+
+    expect(validateFields).toHaveBeenCalledWith([['a']]);
+  });
+});

package/src/flow/models/blocks/form/assignRulesUpdateAssociationValues.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+/**
+ * 从 assignRules 的 targetPath 推导需要注入到请求中的 updateAssociationValues。
+ *
+ * 规则：仅当 targetPath 穿过至少一段关联字段（association）时返回该关联路径：
+ * - user.name -> user
+ * - user.profile.name -> user.profile
+ */
+export function collectUpdateAssociationValuesFromAssignRules(
+  items: Array<{ targetPath?: string } | any>,
+  rootCollection: any,
+): string[] {
+  const list = Array.isArray(items) ? items : [];
+  const out = new Set<string>();
+
+  const getDeepestAssociationPath = (targetPath: string): string | null => {
+    if (!rootCollection || typeof rootCollection.getField !== 'function') return null;
+    if (typeof targetPath !== 'string' || !targetPath.includes('.')) return null;
+
+    const segs = targetPath.split('.').filter(Boolean);
+    if (segs.length < 2) return null;
+
+    let cur = rootCollection;
+    const assocSegs: string[] = [];
+    let deepest: string | null = null;
+    let deepestField: any | null = null;
+
+    // 只遍历到倒数第二段：最后一段视为“属性字段”
+    for (let i = 0; i < segs.length - 1; i++) {
+      const seg = segs[i];
+      const cf = cur?.getField?.(seg);
+      if (!cf?.isAssociationField?.() || !cf?.targetCollection) break;
+      assocSegs.push(seg);
+      deepest = assocSegs.join('.');
+      deepestField = cf;
+      cur = cf.targetCollection;
+    }
+
+    // 特殊：targetPath 仅写入关联对象的 targetKey/filterTargetKey（如 user.id），不属于“更新关联对象属性”，无需注入 updateAssociationValues。
+    // 这种场景通常代表“通过主键选中关联记录”。
+    if (deepest && deepestField) {
+      const lastSeg = segs[segs.length - 1];
+      const rawKey = deepestField?.targetKey ?? deepestField?.targetCollection?.filterTargetKey ?? 'id';
+      const keyFields = Array.isArray(rawKey)
+        ? rawKey.filter((v: any) => typeof v === 'string' && !!v)
+        : typeof rawKey === 'string' && rawKey
+          ? [rawKey]
+          : ['id'];
+      if (typeof lastSeg === 'string' && keyFields.includes(lastSeg)) {
+        return null;
+      }
+    }
+
+    return deepest;
+  };
+
+  for (const it of list) {
+    const targetPath = it?.targetPath ? String(it.targetPath) : '';
+    if (!targetPath) continue;
+    const assoc = getDeepestAssociationPath(targetPath);
+    if (assoc) out.add(assoc);
+  }
+
+  return Array.from(out);
+}

package/src/flow/models/blocks/form/dynamicNamePath.ts

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+
+export type DynamicNamePart = string | number;
+
+/**
+ * Build a dynamic NamePath based on current subform list row index.
+ *
+ * fieldIndex is an array like: ["products:0", "products:2"] (nested lists allowed, including same-name lists).
+ *
+ * For example:
+ * - nameParts: ["products", "products"] + fieldIndex: ["products:0"] => [0, "products"]
+ * - nameParts: ["products", "products", "id"] + fieldIndex: ["products:1", "products:0"] => [0, "id"]
+ */
+export function buildDynamicNamePath(nameParts: DynamicNamePart[], fieldIndex?: string[]): DynamicNamePart[] {
+  if (!fieldIndex?.length) {
+    return nameParts;
+  }
+
+  const last = fieldIndex[fieldIndex.length - 1];
+  const [lastField, indexStr] = String(last).split(':');
+  const idx = Number(indexStr);
+  if (!lastField || !Number.isFinite(idx)) {
+    return nameParts;
+  }
+
+  // Support same-name nested lists by mapping the N-th occurrence in fieldIndex
+  // to the N-th occurrence in nameParts (from left to right).
+  let occurrence = 0;
+  for (const item of fieldIndex) {
+    const [fieldName] = String(item).split(':');
+    if (fieldName === lastField) occurrence += 1;
+  }
+
+  let matchIndex = -1;
+  let seen = 0;
+  for (let i = 0; i < nameParts.length; i++) {
+    if (String(nameParts[i]) === lastField) {
+      seen += 1;
+      if (seen === occurrence) {
+        matchIndex = i;
+        break;
+      }
+    }
+  }
+
+  // Fallback: when nameParts doesn't contain enough occurrences, fall back to last occurrence.
+  if (matchIndex === -1) {
+    for (let i = nameParts.length - 1; i >= 0; i--) {
+      if (String(nameParts[i]) === lastField) {
+        matchIndex = i;
+        break;
+      }
+    }
+  }
+
+  if (matchIndex === -1) {
+    return nameParts;
+  }
+
+  return [idx, ...nameParts.slice(matchIndex + 1)];
+}