@nocobase/client-v2 2.1.0-alpha.45 → 2.1.0-alpha.46

package/src/flow/components/FieldAssignRulesEditor.tsx

@@ -24,7 +24,7 @@ import type { CascaderProps, CollapseProps } from 'antd';
 import React from 'react';
 import { ConditionBuilder } from './ConditionBuilder';
 import { FieldAssignValueInput } from './FieldAssignValueInput';
-import type { FieldAssignCascaderOption } from './fieldAssignOptions';
+import { buildFieldAssignCascaderOptionsFromCollection, type FieldAssignCascaderOption } from './fieldAssignOptions';
 import { isRunJSValue, isVariableExpression, type MetaTreeNode } from '@nocobase/flow-engine';
 import { isToManyAssociationField } from '../internal/utils/modelUtils';
 
@@ -36,6 +36,7 @@ type CollectionFieldLike = {
   type?: unknown;
   interface?: unknown;
   uiSchema?: unknown;
+  target?: unknown;
   targetKey?: unknown;
   targetCollectionTitleFieldName?: unknown;
   targetCollection?: any;
@@ -105,6 +106,7 @@ export interface FieldAssignRulesEditorProps {
   onSyncAssociationTitleField?: (params: SyncAssociationTitleFieldParams) => Promise<void> | void;
   /** 在日期字段下启用“日期变量替换 Constant 位”。 */
   enableDateVariableAsConstant?: boolean;
+  maxAssociationFieldDepth?: number;
 }
 
 export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (props) => {
@@ -123,9 +125,10 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     isTitleFieldCandidate,
     onSyncAssociationTitleField,
     enableDateVariableAsConstant = false,
+    maxAssociationFieldDepth = 2,
   } = props;
 
-  const value = Array.isArray(rawValue) ? rawValue : [];
+  const value = React.useMemo(() => (Array.isArray(rawValue) ? rawValue : []), [rawValue]);
   const [cascaderOptions, setCascaderOptions] = React.useState<FieldAssignCascaderOption[]>(() =>
     Array.isArray(fieldOptions) ? (fieldOptions as FieldAssignCascaderOption[]) : [],
   );
@@ -171,6 +174,19 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     }
   }, [getRuleKey, syncingRuleKey, value]);
 
+  const parseTargetPathToSegments = React.useCallback((targetPath?: string): string[] => {
+    const raw = String(targetPath || '');
+    if (!raw) return [];
+    return raw
+      .split('.')
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }, []);
+
+  const isAssociationFieldLike = React.useCallback((field?: CollectionFieldLike | null) => {
+    return !!(field?.isAssociationField?.() || field?.target || field?.targetCollection);
+  }, []);
+
   const buildCollectionMetaTreeNodes = React.useCallback(
     (collection: any, basePaths: string[], visited: Set<any>): MetaTreeNode[] => {
       if (!collection?.getFields) return [];
@@ -199,7 +215,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
           paths: [...basePaths, name],
         };
 
-        const isAssoc = !!f.isAssociationField?.();
+        const isAssoc = isAssociationFieldLike(f);
         const isToMany = isToManyAssociationField(f);
         if (isAssoc && !isToMany && f.targetCollection) {
           node.children = async () =>
@@ -211,7 +227,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
       return nodes;
     },
-    [t],
+    [isAssociationFieldLike, t],
   );
 
   const buildItemMetaTree = React.useCallback(
@@ -226,7 +242,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
       for (let i = 0; i < segs.length; i++) {
         const seg = segs[i] as string;
         const field = current?.getField?.(seg);
-        if (!field?.isAssociationField?.()) break;
+        if (!isAssociationFieldLike(field)) break;
         const toMany = isToManyAssociationField(field);
         const nextCollection = field?.targetCollection;
         if (!nextCollection) break;
@@ -291,7 +307,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
       return [buildObjectNode(levels.length - 1, ['item'], 'item', 'Current item')];
     },
-    [buildCollectionMetaTreeNodes, rootCollection, t],
+    [buildCollectionMetaTreeNodes, isAssociationFieldLike, parseTargetPathToSegments, rootCollection, t],
   );
 
   const patchItem = (index: number, patch: Partial<FieldAssignRuleItem>) => {
@@ -381,15 +397,6 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     [t],
   );
 
-  const parseTargetPathToSegments = React.useCallback((targetPath?: string): string[] => {
-    const raw = String(targetPath || '');
-    if (!raw) return [];
-    return raw
-      .split('.')
-      .map((s) => s.trim())
-      .filter(Boolean);
-  }, []);
-
   const getFieldLabel = (targetPath?: string) => {
     const segs = parseTargetPathToSegments(targetPath);
     if (!segs.length) return undefined;
@@ -413,7 +420,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
             : seg,
         ),
       );
-      if (field?.isAssociationField?.() && field?.targetCollection) {
+      if (isAssociationFieldLike(field as CollectionFieldLike) && field?.targetCollection) {
         collection = field.targetCollection;
       }
     }
@@ -435,7 +442,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
         const isLast = i === segs.length - 1;
         if (isLast) {
-          if (!field?.isAssociationField?.() || !field?.targetCollection) return null;
+          if (!isAssociationFieldLike(field) || !field?.targetCollection) return null;
 
           const targetCollection = field.targetCollection;
           const targetFields =
@@ -502,7 +509,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
           };
         }
 
-        if (!field?.isAssociationField?.() || !field?.targetCollection) {
+        if (!isAssociationFieldLike(field) || !field?.targetCollection) {
           return null;
         }
         collection = field.targetCollection;
@@ -510,7 +517,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
 
       return null;
     },
-    [isTitleFieldCandidate, parseTargetPathToSegments, rootCollection, t],
+    [isAssociationFieldLike, isTitleFieldCandidate, parseTargetPathToSegments, rootCollection, t],
   );
 
   const resolveTargetCollectionBySegments = React.useCallback(
@@ -519,42 +526,24 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
       let collection = rootCollection;
       for (const seg of segments) {
         const field = collection?.getField?.(seg);
-        if (!field?.isAssociationField?.() || !field?.targetCollection) {
+        if (!isAssociationFieldLike(field) || !field?.targetCollection) {
           return null;
         }
         collection = field.targetCollection;
       }
       return collection || null;
     },
-    [rootCollection],
+    [isAssociationFieldLike, rootCollection],
   );
 
   const buildChildrenFromCollection = React.useCallback(
-    (collection: any): FieldAssignCascaderOption[] => {
-      const fields = typeof collection?.getFields === 'function' ? collection.getFields() || [] : [];
-      const out: FieldAssignCascaderOption[] = [];
-      for (const rawField of fields) {
-        if (!rawField) continue;
-        const f = rawField as CollectionFieldLike;
-        const fieldInterface = typeof f.interface === 'string' ? f.interface : undefined;
-        if (!fieldInterface) continue;
-        if (fieldInterface === 'formula') continue;
-
-        const name = String(f.name || '');
-        if (!name) continue;
-
-        const title = t(typeof f.title === 'string' ? f.title : name);
-        const isAssoc = !!f.isAssociationField?.();
-        const hasTarget = !!f.targetCollection;
-        out.push({
-          label: title,
-          value: name,
-          isLeaf: !(isAssoc && hasTarget),
-        });
-      }
-      return out;
+    (collection: any, associationDepth: number): FieldAssignCascaderOption[] => {
+      return buildFieldAssignCascaderOptionsFromCollection(collection, t, {
+        associationDepth,
+        maxAssociationFieldDepth,
+      });
     },
-    [t],
+    [maxAssociationFieldDepth, t],
   );
 
   const loadCascaderData = React.useCallback<NonNullable<CascaderProps<FieldAssignCascaderOption>['loadData']>>(
@@ -573,7 +562,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
         return;
       }
 
-      const children = buildChildrenFromCollection(targetCollection);
+      const children = buildChildrenFromCollection(targetCollection, segments.length);
       if (!children.length) {
         target.isLeaf = true;
       } else {
@@ -889,6 +878,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
                 value={item.value}
                 onChange={(v) => patchItem(index, { value: v })}
                 extraMetaTree={extraMetaTree}
+                maxAssociationFieldDepth={maxAssociationFieldDepth}
                 {...(getValueInputProps?.(item, index) || {})}
                 enableDateVariableAsConstant={enableDateVariableAsConstant}
                 associationFieldNamesOverride={
@@ -959,6 +949,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
                 value={item.condition || { logic: '$and', items: [] }}
                 onChange={(condition) => patchItem(index, { condition })}
                 extraMetaTree={extraMetaTree}
+                maxAssociationFieldDepth={2}
               />
             </div>
           )}

package/src/flow/components/FieldAssignValueInput.tsx

@@ -40,6 +40,7 @@ import { resolveOperatorComponent } from '../internal/utils/operatorSchemaHelper
 import { InputFieldModel } from '../models/fields/InputFieldModel';
 import { normalizeFilterValueByOperator } from '../models/blocks/filter-form/valueNormalization';
 import { FieldAssignExactDatePicker, type ExactDatePickerMode } from './FieldAssignExactDatePicker';
+import { limitAssociationMetaTree } from './filter/metaTreeAssociationDepth';
 
 const DATE_FIELD_INTERFACES = new Set(['date', 'datetime', 'datetimeNoTz', 'createdAt', 'updatedAt', 'unixTimestamp']);
 
@@ -340,6 +341,7 @@ interface Props {
    * 默认 false，保持历史行为。
    */
   enableDateVariableAsConstant?: boolean;
+  maxAssociationFieldDepth?: number;
 }
 
 type ResolvedFieldContext = {
@@ -718,6 +720,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
   preferFormItemFieldModel,
   associationFieldNamesOverride,
   enableDateVariableAsConstant = false,
+  maxAssociationFieldDepth = 2,
 }) => {
   const flowCtx = useFlowContext<FlowModelContext>();
   const normalizeEventValue = React.useCallback((eventOrValue: unknown) => {
@@ -859,7 +862,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       fieldName,
       collectionField: nested.collectionField || null,
     };
-  }, [flowCtx.model, itemModel, resolveNestedAssociationField, targetPath]);
+  }, [flowCtx, itemModel, resolveNestedAssociationField, targetPath]);
 
   const { collection, dataSource, blockModel, fieldPath, fieldName, collectionField: cf } = resolved;
   const itemCollectionField = (resolved?.itemModel as any)?.context?.collectionField;
@@ -1232,7 +1235,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       );
     };
     return C;
-  }, [placeholder, tempRoot, coerceEmptyValueForRenderer, normalizeEventValue]);
+  }, [placeholder, tempRoot, coerceEmptyValueForRenderer, normalizeEventValue, operator]);
 
   const DateVariableConstantEditor = React.useMemo(() => {
     const C: React.FC<any> = (inputProps) => {
@@ -1408,6 +1411,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       const extra = extraMetaTreeRef.current;
       const extraTree = Array.isArray(extra) ? extra : [];
       const mergedBase = mergeItemMetaTreeForAssignValue(base as MetaTreeNode[], extraTree as MetaTreeNode[]);
+      const limitedBase = limitAssociationMetaTree(mergedBase, { maxAssociationDepth: maxAssociationFieldDepth });
       return [
         {
           title: tExpr('Constant'),
@@ -1418,10 +1422,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
         },
         { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
         { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-        ...mergedBase,
+        ...limitedBase,
       ];
     };
-  }, [flowCtx, ConstantEditor, NullComponent, RunJSComponent]);
+  }, [flowCtx, ConstantEditor, NullComponent, RunJSComponent, maxAssociationFieldDepth]);
 
   const displayValue = React.useMemo(() => {
     if (!useDateVariableConstant) {

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

@@ -108,6 +108,54 @@ describe('FieldAssignRulesEditor', () => {
     };
   };
 
+  const createAssociationFixtureWithoutIsAssociationField = () => {
+    const profileCollection = {
+      titleField: 'name',
+      filterTargetKey: 'id',
+      getField: (name: string) => {
+        if (name === 'name') {
+          return { name: 'name', title: 'Name', interface: 'input' };
+        }
+        if (name === 'nickname') {
+          return { name: 'nickname', title: 'Nickname', interface: 'input' };
+        }
+        return null;
+      },
+      getFields: () => [
+        {
+          name: 'name',
+          title: 'Name',
+          interface: 'input',
+        },
+        {
+          name: 'nickname',
+          title: 'Nickname',
+          interface: 'input',
+        },
+      ],
+    };
+
+    const profileField: any = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetKey: 'id',
+      targetCollection: profileCollection,
+    };
+
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+
+    return {
+      profileCollection,
+      rootCollection,
+    };
+  };
+
   const openAdvancedPanel = async () => {
     await userEvent.click(screen.getByRole('button', { name: /Advanced/i }));
     await screen.findByText('Title field');
@@ -175,6 +223,68 @@ describe('FieldAssignRulesEditor', () => {
     });
   });
 
+  it('recognizes lightweight association fields without isAssociationField()', async () => {
+    const { rootCollection } = createAssociationFixtureWithoutIsAssociationField();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile',
+        enable: true,
+        targetPath: 'profile',
+        mode: 'assign',
+      },
+    ];
+
+    const { container } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+          isTitleFieldCandidate={() => true}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      const input = container.querySelector('[data-testid="mock-value-input"]');
+      expect(input?.getAttribute('data-assoc-label')).toBe('name');
+      expect(input?.getAttribute('data-assoc-value')).toBe('id');
+    });
+  });
+
+  it('resolves nested labels and item meta tree through lightweight association fields', async () => {
+    const { rootCollection } = createAssociationFixtureWithoutIsAssociationField();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    const { container } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+          isTitleFieldCandidate={() => true}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(container.textContent).toContain('Profile / Nickname');
+      const input = container.querySelector('[data-testid="mock-value-input"]');
+      expect(input?.getAttribute('data-extra')).toBe('yes');
+    });
+  });
+
   it('saves selected title field into current assign rule without syncing', async () => {
     const { rootCollection, value } = createAssociationFixture();
     const onChange = vi.fn();
@@ -785,7 +895,8 @@ describe('FieldAssignRulesEditor', () => {
     expect(merged.map((node) => node.name)).toEqual(['formValues', 'item', 'user']);
     expect(merged.filter((node) => node.name === 'item')).toHaveLength(1);
 
-    const itemNode = merged.find((node) => node.name === 'item')!;
+    const itemNode = merged.find((node) => node.name === 'item');
+    expect(itemNode).toBeTruthy();
     const parent = (itemNode.children as MetaTreeNode[]).find((node) => node.name === 'parentItem');
     expect(parent).toBeTruthy();
 

package/src/flow/components/__tests__/fieldAssignOptions.test.ts

@@ -9,7 +9,10 @@
 
 import { describe, expect, it } from 'vitest';
 import { buildCustomFieldTargetPath } from '../../internal/utils/modelUtils';
-import { collectFieldAssignCascaderOptions } from '../fieldAssignOptions';
+import {
+  buildFieldAssignCascaderOptionsFromCollection,
+  collectFieldAssignCascaderOptions,
+} from '../fieldAssignOptions';
 
 describe('fieldAssignOptions', () => {
   it('marks subform node as non-leaf so Cascader can lazy-load target collection fields', () => {
@@ -94,4 +97,71 @@ describe('fieldAssignOptions', () => {
       options.some((o: any) => o?.value === customTargetPath && o?.label === 'Custom age' && o?.isLeaf === true),
     ).toBe(true);
   });
+
+  it('hides configured association fields deeper than relation / relation / field', () => {
+    const makeItem = (fieldPath: string, field: any, label: string) => ({
+      props: { label },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: field },
+        },
+      },
+    });
+
+    const companyField = {
+      name: 'company',
+      title: 'Company',
+      interface: 'm2o',
+      target: 'companies',
+      isAssociationField: () => true,
+      targetCollection: { getFields: () => [] },
+    };
+    const nameField = {
+      name: 'name',
+      title: 'Name',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const formBlockModel = {
+      context: { collection: null },
+      subModels: {
+        grid: {
+          subModels: {
+            items: [
+              makeItem('users.department.name', nameField, 'Department name'),
+              makeItem('users.department.company', companyField, 'Company'),
+            ],
+          },
+        },
+      },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+
+    expect(options.map((item) => item.value)).toContain('name');
+    expect(options.map((item) => item.value)).not.toContain('company');
+  });
+
+  it('hides lazy-loaded association selector options after two association levels', () => {
+    const collection = {
+      getFields: () => [
+        { name: 'name', title: 'Name', interface: 'input' },
+        {
+          name: 'company',
+          title: 'Company',
+          interface: 'm2o',
+          target: 'companies',
+          targetCollection: { getFields: () => [] },
+        },
+      ],
+    };
+
+    const options = buildFieldAssignCascaderOptionsFromCollection(collection, (s) => s, { associationDepth: 2 });
+
+    expect(options.map((item) => item.value)).toEqual(['name']);
+  });
 });