@nocobase/client-v2 2.1.35 → 2.1.37

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -10,23 +10,20 @@
 import React from 'react';
 import { Input } from 'antd';
 import { define, observable } from '@formily/reactive';
-import {
-  FlowModelRenderer,
-  FormItem,
-  VariableInput,
-  tExpr,
-  isVariableExpression,
-  parseValueToPath,
-  isRunJSValue,
-  EditableItemModel,
-  jioToJoiSchema,
-} from '@nocobase/flow-engine';
+import { FlowModelRenderer, FormItem, tExpr, EditableItemModel, jioToJoiSchema } from '@nocobase/flow-engine';
 // 无需类型导入（避免未使用的类型）
 import { FormItemModel } from '../form/FormItemModel';
 import { EditFormModel } from '../form/EditFormModel';
 import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
+import {
+  DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+  FieldValueVariableInput,
+  getFieldInterface,
+  isDateLikeField,
+  resolveDateVariableComponentProps,
+} from '../../../components/field-value-variable';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -285,7 +282,9 @@ export class AssignFormItemModel extends FormItemModel {
         ) : null;
       };
 
-      const NullComponent: React.FC = () => <Input placeholder={'<Null>'} readOnly style={{ width: '100%' }} />;
+      const NullComponent: React.FC = () => (
+        <Input placeholder={`<${this.context.t?.('Null') ?? 'Null'}>`} readOnly style={{ width: '100%' }} />
+      );
 
       const RunJSComponent: React.FC<any> = (inputProps: any) => {
         return (
@@ -298,46 +297,18 @@ export class AssignFormItemModel extends FormItemModel {
         );
       };
 
-      const converters = {
-        renderInputComponent: (meta: any) => {
-          const firstPath = meta?.paths?.[0];
-          if (firstPath === 'constant') return ConstantValueEditor as any;
-          if (firstPath === 'null') return NullComponent as any;
-          if (firstPath === 'runjs') return RunJSComponent as any;
-          return undefined;
-        },
-        resolveValueFromPath: (item: any) => {
-          const firstPath = item?.paths?.[0];
-          if (firstPath === 'constant') return '';
-          if (firstPath === 'null') return null;
-          if (firstPath === 'runjs') return { code: '', version: 'v2' };
-          return undefined;
-        },
-        resolvePathFromValue: (currentValue: any) => {
-          if (currentValue === null) return ['null'];
-          if (isRunJSValue(currentValue)) return ['runjs'];
-          return isVariableExpression(currentValue) ? parseValueToPath(currentValue) : ['constant'];
-        },
-      } as any;
-
-      // 合并变量树：在最前面追加“常量/空值”两个选项
-      const mergedMetaTree = async () => {
+      const baseMetaTree = async () => {
         const getTree = (this.context as any)?.getPropertyMetaTree;
-        const base: any[] = typeof getTree === 'function' ? await getTree() : [];
-        return [
-          {
-            title: tExpr('Constant'),
-            name: 'constant',
-            type: 'string',
-            paths: ['constant'],
-            render: ConstantValueEditor,
-          },
-          { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-          ...base,
-        ];
+        return typeof getTree === 'function' ? await getTree() : [];
       };
 
+      const targetCollectionField = collection?.getField?.(this.fieldPath);
+      const targetFieldInterface = getFieldInterface(targetCollectionField);
+      const dateLike = isDateLikeField(targetCollectionField, this.fieldPath?.split('.').slice(-1)[0]);
+      const dateComponentProps = dateLike
+        ? resolveDateVariableComponentProps(targetCollectionField, targetFieldInterface)
+        : DEFAULT_DATE_VARIABLE_COMPONENT_PROPS;
+
       // 计算 label：优先使用配置中的 label，其次集合字段标题，最后回退字段路径
       let labelText = this.props?.label ?? this.fieldPath ?? '';
       const cf = collection?.getField?.(this.fieldPath);
@@ -357,14 +328,18 @@ export class AssignFormItemModel extends FormItemModel {
             const formValue = formBindingProps?.__assign_value__;
             const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
             return (
-              <VariableInput
+              <FieldValueVariableInput
                 value={mergedValue}
-                onChange={(v: any) => {
+                onChange={(v) => {
                   this.assignValue = v;
                   formBindingProps?.__assign_trigger__?.(v);
                 }}
-                metaTree={mergedMetaTree}
-                converters={converters}
+                baseMetaTree={baseMetaTree}
+                constantComponent={ConstantValueEditor}
+                nullComponent={NullComponent}
+                runJSComponent={RunJSComponent}
+                isDateLikeField={dateLike}
+                dateComponentProps={dateComponentProps}
                 clearValue={''}
               />
             );

package/src/flow/models/blocks/form/__tests__/FormBlockModel.test.tsx

@@ -465,11 +465,17 @@ describe('FormBlockModel (form/formValues injection & server resolve anchors)',
 
   it('builds non-empty contextParams for ctx.formValues.* deep association path', async () => {
     const model = await setupFormModel();
+    const sessionPayload = Buffer.from(JSON.stringify({ userId: 1, signInTime: 'form-record-slots' })).toString(
+      'base64url',
+    );
     // 注入 api mock 到引擎上下文，拦截 variables:resolve 的请求
     const api = {
+      auth: { token: `test.${sessionPayload}.sig` },
       request: vi.fn(async (config: any) => {
-        const payload = config?.data?.values || {};
-        const batch = payload.batch || [];
+        const requestValues = config?.data?.values || {};
+        const batch = requestValues.batch || [];
+        expect(batch[0]?.rd).toEqual(expect.any(String));
+        expect(batch[0]?.template).toEqual({ who: '{{ ctx.formValues.assignees.org.name }}' });
         const cp = batch[0]?.contextParams || {};
         const keys = Object.keys(cp).sort();
         // 聚合为单键，不再使用索引键

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

@@ -3999,6 +3999,404 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(formStub.getFieldValue(['users', 0, 'user', 'id'])).toBe(1);
   });
 
+  it('assigns a to-one association from a sibling association in the same to-many row', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const secondary = { id: 2, name: 'Secondary' };
+    const formStub = createFormStub({ users: [{ user: null, secondaryUser: null }] });
+
+    const blockModel: any = {
+      uid: 'form-assign-assoc-to-many-sibling',
+      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);
+    const userCollection: any = { getField: () => null };
+    const userField: any = { isAssociationField: () => true, type: 'belongsTo', targetCollection: userCollection };
+    const usersItemCollection: any = {
+      getField: (name: string) => (name === 'user' || name === 'secondaryUser' ? userField : null),
+    };
+    const usersField: any = { isAssociationField: () => true, type: 'hasMany', targetCollection: usersItemCollection };
+    const collection: any = { getField: (name: string) => (name === 'users' ? usersField : null) };
+    blockCtx.defineProperty('collection', { value: collection });
+
+    const rowModel: any = {
+      uid: 'users.user:users:0',
+      isFork: true,
+      forkId: 'users:0',
+      subModels: { field: { context: { collectionField: userField } } },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'users.user' };
+        return undefined;
+      },
+    };
+    const rowCtx = createFieldContext(runtime);
+    rowCtx.defineProperty('blockModel', { value: blockModel });
+    rowCtx.defineProperty('collection', { value: collection });
+    rowCtx.defineProperty('fieldIndex', { value: ['users:0'] });
+    rowCtx.defineProperty('model', { value: rowModel });
+    rowModel.context = rowCtx;
+
+    blockCtx.defineProperty('engine', {
+      value: { forEachModel: (callback: (model: unknown) => void) => callback(rowModel) },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'r1',
+        enable: true,
+        targetPath: 'users.user',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.item.parentItem.value.secondaryUser }}',
+      },
+    ]);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['users', 0, 'secondaryUser'], value: secondary }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'user'])).toEqual(secondary));
+
+    await runtime.setFormValues(blockCtx, [{ path: ['users', 0, 'user'], value: { id: 3, name: 'Manual' } }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'user'])).toEqual(secondary));
+
+    const nextSecondary = { id: 4, name: 'Next secondary' };
+    await runtime.setFormValues(blockCtx, [{ path: ['users', 0, 'secondaryUser'], value: nextSecondary }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'user'])).toEqual(nextSecondary));
+  });
+
+  it('materializes assigned proxies so later to-many rows continue updating', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const initialSecondary = { id: 2, name: 'Initial secondary', roleCodes: ['admin'] };
+    const nextSecondary = { id: 4, name: 'Next secondary', roleCodes: ['editor'] };
+    type UserRow = {
+      user: unknown;
+      secondaryUser: typeof initialSecondary | null;
+    };
+    const store: { users: UserRow[] } = {
+      users: [{ user: null, secondaryUser: initialSecondary }],
+    };
+    type FormNamePath = Parameters<FormInstance['getFieldValue']>[0];
+    const formStub = {
+      getFieldValue: (namePath: FormNamePath) => lodashGet(store, namePath),
+      setFieldValue: (namePath: FormNamePath, value: unknown) => lodashSet(store, namePath, value),
+      // Match Ant Form: the outer store is plain, but nested values may still be reactive proxies.
+      getFieldsValue: () => store,
+      setFieldsValue: (patch: Partial<typeof store>) => lodashMerge(store, patch),
+    };
+
+    const blockModel = {
+      uid: 'form-assign-assoc-to-many-later-row-reactive-proxy',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+      context: undefined as unknown,
+    };
+
+    const runtime = new FormValueRuntime({
+      model: blockModel as unknown as ConstructorParameters<typeof FormValueRuntime>[0]['model'],
+      getForm: () => formStub as unknown as FormInstance,
+    });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    const userCollection = { getField: () => null };
+    const userField = { isAssociationField: () => true, type: 'belongsTo', targetCollection: userCollection };
+    const usersItemCollection = {
+      getField: (name: string) => (name === 'user' || name === 'secondaryUser' ? userField : null),
+    };
+    const usersField = { isAssociationField: () => true, type: 'hasMany', targetCollection: usersItemCollection };
+    const collection = { getField: (name: string) => (name === 'users' ? usersField : null) };
+    blockCtx.defineProperty('collection', { value: collection });
+
+    const createRowModel = (index: number) => {
+      const forkId = `users:${index}`;
+      const rowCtx = createFieldContext(runtime);
+      const rowModel = {
+        uid: `users.user:${forkId}`,
+        isFork: true,
+        forkId,
+        subModels: { field: { context: { collectionField: userField } } },
+        getStepParams(flowKey: string, stepKey: string) {
+          if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'users.user' };
+          return undefined;
+        },
+        context: rowCtx,
+      };
+      rowCtx.defineProperty('blockModel', { value: blockModel });
+      rowCtx.defineProperty('collection', { value: collection });
+      rowCtx.defineProperty('fieldIndex', { value: [forkId] });
+      rowCtx.defineProperty('model', { value: rowModel });
+      return rowModel;
+    };
+    const rowModels = [createRowModel(0)];
+
+    blockCtx.defineProperty('engine', {
+      value: { forEachModel: (callback: (model: unknown) => void) => rowModels.forEach(callback) },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'user-from-row-sibling',
+        enable: true,
+        targetPath: 'users.user',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.item.parentItem.value.secondaryUser }}',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'user'])).toEqual(initialSecondary));
+    const assignedUser = formStub.getFieldValue(['users', 0, 'user']);
+    const assignedRoleCodes = formStub.getFieldValue(['users', 0, 'user', 'roleCodes']);
+    expect(assignedUser.constructor).toBe(Object);
+    expect(Array.isArray(assignedRoleCodes)).toBe(true);
+    expect(assignedRoleCodes.constructor).toBe(Array);
+
+    const secondRow: UserRow = { user: null, secondaryUser: null };
+    store.users.push(secondRow);
+    const addedRows: Array<UserRow | undefined> = new Array(2);
+    addedRows[1] = secondRow;
+    expect(() => runtime.handleFormValuesChange({ users: addedRows }, store)).not.toThrow();
+
+    const row1 = createRowModel(1);
+    rowModels.push(row1);
+    engineEmitter.emit('model:mounted', { model: row1 });
+
+    secondRow.secondaryUser = nextSecondary;
+    const changedRows: Array<Partial<UserRow> | undefined> = new Array(2);
+    changedRows[1] = { secondaryUser: nextSecondary };
+    expect(0 in changedRows).toBe(false);
+
+    expect(() => runtime.handleFormValuesChange({ users: changedRows }, store)).not.toThrow();
+    await waitFor(() => expect(formStub.getFieldValue(['users', 1, 'user'])).toEqual(nextSecondary));
+    expect(formStub.getFieldValue(['users', 0, 'user'])).toEqual(initialSecondary);
+  });
+
+  it('assigns a to-many association from a sibling association in the same to-many row', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const initialRoles = [{ id: 2, name: 'Initial role' }];
+    const formStub = createFormStub({ users: [{ roles: [], secondaryRoles: [] }] });
+
+    const blockModel: any = {
+      uid: 'form-assign-to-many-assoc-from-to-many-row-sibling',
+      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);
+    const roleCollection: any = { filterTargetKey: 'id', getField: () => null };
+    const rolesField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: roleCollection,
+    };
+    const usersItemCollection: any = {
+      getField: (name: string) => (name === 'roles' || name === 'secondaryRoles' ? rolesField : null),
+    };
+    const usersField: any = { isAssociationField: () => true, type: 'hasMany', targetCollection: usersItemCollection };
+    const collection: any = { getField: (name: string) => (name === 'users' ? usersField : null) };
+    blockCtx.defineProperty('collection', { value: collection });
+
+    const rowModel: any = {
+      uid: 'users.roles:users:0',
+      isFork: true,
+      forkId: 'users:0',
+      subModels: { field: { context: { collectionField: rolesField } } },
+      getStepParams(flowKey: string, stepKey: string) {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'users.roles' };
+        return undefined;
+      },
+    };
+    const rowCtx = createFieldContext(runtime);
+    rowCtx.defineProperty('blockModel', { value: blockModel });
+    rowCtx.defineProperty('collection', { value: collection });
+    rowCtx.defineProperty('fieldIndex', { value: ['users:0'] });
+    rowCtx.defineProperty('model', { value: rowModel });
+    rowModel.context = rowCtx;
+
+    blockCtx.defineProperty('engine', {
+      value: { forEachModel: (callback: (model: unknown) => void) => callback(rowModel) },
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'roles-from-row-sibling',
+        enable: true,
+        targetPath: 'users.roles',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+        value: '{{ ctx.item.parentItem.value.secondaryRoles }}',
+      },
+    ]);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['users', 0, 'secondaryRoles'], value: initialRoles }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'roles'])).toEqual(initialRoles));
+
+    const nextRoles = [{ id: 3, name: 'Next role' }];
+    await runtime.setFormValues(blockCtx, [{ path: ['users', 0, 'secondaryRoles'], value: nextRoles }], {
+      source: 'user',
+    });
+    await waitFor(() => expect(formStub.getFieldValue(['users', 0, 'roles'])).toEqual(nextRoles));
+  });
+
+  it('preserves the PopupSubTable outer item chain for a top-level to-one association target', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const initialAssignee = { id: 2, name: 'Initial assignee' };
+    const nextAssignee = { id: 3, name: 'Next assignee' };
+    const outerValue = observable({ defaultAssignee: initialAssignee });
+    const formStub = createFormStub({ assignee: null });
+
+    const blockModel: any = {
+      uid: 'popup-sub-table-form-assign-parent-item',
+      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);
+    const userCollection: any = { filterTargetKey: 'id', getField: () => null };
+    const assigneeField: any = {
+      isAssociationField: () => true,
+      type: 'belongsTo',
+      targetCollection: userCollection,
+    };
+    const collection: any = { getField: (name: string) => (name === 'assignee' ? assigneeField : null) };
+    const outerItem = { index: 0, length: 1, value: outerValue };
+    blockCtx.defineProperty('collection', { value: collection });
+    blockCtx.defineProperty('item', {
+      get: () => ({
+        index: 1,
+        length: 3,
+        __is_new__: true,
+        __is_stored__: false,
+        value: blockCtx.formValues,
+        parentItem: outerItem,
+      }),
+      cache: false,
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'assignee-from-popup-parent',
+        enable: true,
+        targetPath: 'assignee',
+        mode: 'assign',
+        condition: {
+          logic: '$and',
+          items: [
+            { path: '{{ ctx.item.parentItem.index }}', operator: '$eq', value: 1 },
+            { path: '{{ ctx.item.parentItem.length }}', operator: '$eq', value: 3 },
+            { path: '{{ ctx.item.parentItem.__is_new__ }}', operator: '$eq', value: true },
+            { path: '{{ ctx.item.parentItem.__is_stored__ }}', operator: '$eq', value: false },
+          ],
+        },
+        value: '{{ ctx.item.parentItem.parentItem.value.defaultAssignee }}',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['assignee'])).toEqual(initialAssignee));
+
+    outerValue.defaultAssignee = nextAssignee;
+    await waitFor(() => expect(formStub.getFieldValue(['assignee'])).toEqual(nextAssignee));
+  });
+
+  it('preserves the PopupSubTable outer item chain for a top-level to-many association target', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const initialReviewers = [{ id: 2, name: 'Initial reviewer' }];
+    const nextReviewers = [{ id: 3, name: 'Next reviewer' }];
+    const outerValue = observable({ defaultReviewers: initialReviewers });
+    const formStub = createFormStub({ reviewers: [] });
+
+    const blockModel: any = {
+      uid: 'popup-sub-table-form-assign-to-many-parent-item',
+      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);
+    const userCollection: any = { filterTargetKey: 'id', getField: () => null };
+    const reviewersField: any = {
+      isAssociationField: () => true,
+      type: 'belongsToMany',
+      targetCollection: userCollection,
+    };
+    const collection: any = { getField: (name: string) => (name === 'reviewers' ? reviewersField : null) };
+    const outerItem = { index: 0, length: 1, value: outerValue };
+    blockCtx.defineProperty('collection', { value: collection });
+    blockCtx.defineProperty('item', {
+      get: () => ({
+        index: 1,
+        length: 3,
+        __is_new__: true,
+        __is_stored__: false,
+        value: blockCtx.formValues,
+        parentItem: outerItem,
+      }),
+      cache: false,
+    });
+    blockModel.context = blockCtx;
+
+    runtime.syncAssignRules([
+      {
+        key: 'reviewers-from-popup-parent',
+        enable: true,
+        targetPath: 'reviewers',
+        mode: 'assign',
+        condition: {
+          logic: '$and',
+          items: [
+            { path: '{{ ctx.item.parentItem.index }}', operator: '$eq', value: 1 },
+            { path: '{{ ctx.item.parentItem.length }}', operator: '$eq', value: 3 },
+            { path: '{{ ctx.item.parentItem.__is_new__ }}', operator: '$eq', value: true },
+            { path: '{{ ctx.item.parentItem.__is_stored__ }}', operator: '$eq', value: false },
+          ],
+        },
+        value: '{{ ctx.item.parentItem.parentItem.value.defaultReviewers }}',
+      },
+    ]);
+
+    await waitFor(() => expect(formStub.getFieldValue(['reviewers'])).toEqual(initialReviewers));
+
+    outerValue.defaultReviewers = nextReviewers;
+    await waitFor(() => expect(formStub.getFieldValue(['reviewers'])).toEqual(nextReviewers));
+  });
+
   it('does not write to to-many nested path without row index', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();

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

@@ -83,6 +83,15 @@ type ToManyAggregateSourceInfo = {
   lastWrite?: FormValueWriteMeta;
 };
 
+type RuntimeItemChain = {
+  index?: number;
+  length?: number;
+  __is_new__?: boolean;
+  __is_stored__?: boolean;
+  value: unknown;
+  parentItem?: RuntimeItemChain;
+};
+
 export type RuleEngineOptions = {
   getBlockModelUid: () => string;
   getActionName: () => string | undefined;
@@ -2038,7 +2047,7 @@ export class RuleEngine {
     // - parentItem：上级项（同结构，可链式 parentItem.parentItem...）
     // 计算顺序：
     // 1) 优先按 targetNamePath 从 formValues 构建“关联链 item”
-    // 2) 若无法构建（例如目标字段是顶层路径），回退到上游显式注入的 baseCtx.item
+    // 2) 若无法构建（例如目标字段是顶层非关联字段），回退到上游显式注入的 baseCtx.item
     //    （如 PopupSubTable 新增弹窗传入的 parentItem 链）
     let itemCached: any;
     let itemCachedReady = false;
@@ -2209,9 +2218,23 @@ export class RuleEngine {
         parentItem,
       };
     };
-    const defaultRoot = buildNode(trackingFormValues, undefined, undefined, undefined);
-    // item 仅用于“关系字段的子路径”场景；
-    // 顶层字段/非关联嵌套对象字段应使用 formValues。
+    const blockCtx = this.options.getBlockContext();
+    const formRootItem = (() => {
+      try {
+        const item = blockCtx?.item as RuntimeItemChain | undefined;
+        if (!item || typeof item !== 'object') return undefined;
+        return item.value === blockCtx?.formValues ? item : undefined;
+      } catch {
+        return undefined;
+      }
+    })();
+    const defaultRoot = {
+      ...buildNode(trackingFormValues, formRootItem?.index, formRootItem?.length, formRootItem?.parentItem),
+      __is_new__: formRootItem?.__is_new__ ?? trackingFormValues?.__is_new__,
+      __is_stored__: formRootItem?.__is_stored__ ?? trackingFormValues?.__is_stored__,
+    };
+    // item 用于“关系字段目标或其子路径”场景；
+    // 顶层非关联字段/非关联嵌套对象字段应使用 formValues。
     if (!targetNamePath || !Array.isArray(targetNamePath) || !targetNamePath.length) return undefined;
     if (!rootCollection?.getField) return undefined;
 
@@ -2219,7 +2242,9 @@ export class RuleEngine {
     const prefix: NamePath = [];
     let collection = rootCollection;
 
-    for (let i = 0; i < targetNamePath.length - 1; i++) {
+    // The target itself can be an association. Keep that final association in the item chain so
+    // ctx.item.parentItem continues to point at the containing row instead of skipping directly to the form root.
+    for (let i = 0; i < targetNamePath.length; i++) {
       const seg = targetNamePath[i];
       if (typeof seg !== 'string') break;
 
@@ -2231,9 +2256,12 @@ export class RuleEngine {
 
       if (toMany) {
         const next = targetNamePath[i + 1];
-        if (typeof next !== 'number') break;
-        prefix.push(next);
-        i += 1;
+        if (typeof next === 'number') {
+          prefix.push(next);
+          i += 1;
+        } else if (i !== targetNamePath.length - 1) {
+          break;
+        }
       }
 
       const targetCollection = field?.targetCollection;
@@ -2248,9 +2276,11 @@ export class RuleEngine {
       const assocEntry = assocEntries[idx];
       const value = _.get(trackingFormValues, assocEntry.path);
       const lastSeg = assocEntry.path[assocEntry.path.length - 1];
-      const index = assocEntry.toMany && typeof lastSeg === 'number' ? lastSeg : undefined;
+      const isIndexedToManyItem = assocEntry.toMany && typeof lastSeg === 'number';
+      const index = isIndexedToManyItem ? lastSeg : undefined;
       const length = (() => {
         if (!assocEntry.toMany) return undefined;
+        if (!isIndexedToManyItem) return Array.isArray(value) ? value.length : undefined;
         // assocEntry.path: [..., associationKey, rowIndex]
         const listPath = assocEntry.path.slice(0, -1);
         const list = _.get(trackingFormValues, listPath);