@nocobase/client-v2 2.1.10 → 2.1.12

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

@@ -285,6 +285,433 @@ describe('FieldAssignRulesEditor', () => {
     });
   });
 
+  it('preloads full association children when configured options already contain partial children', async () => {
+    const nameField = { name: 'name', title: 'Name', interface: 'input' };
+    const nicknameField = { name: 'nickname', title: 'Nickname', interface: 'input' };
+    const profileCollection = {
+      getField: (name: string) => {
+        if (name === 'name') return nameField;
+        if (name === 'nickname') return nicknameField;
+        return null;
+      },
+      getFields: vi.fn(() => [nameField, nicknameField]),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const fieldOptions = [
+      {
+        label: 'Profile',
+        value: 'profile',
+        isLeaf: false,
+        children: [{ label: 'Name', value: 'name', isLeaf: true }],
+      },
+    ];
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={fieldOptions}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(profileCollection.getFields).toHaveBeenCalled();
+    });
+  });
+
+  it('keeps configured child paths expandable when target collection cannot be resolved', async () => {
+    const configuredParent = {
+      label: 'Legacy profile',
+      value: 'legacyProfile',
+      isLeaf: false,
+      children: [{ label: 'Nickname', value: 'nickname', isLeaf: true }],
+    };
+    const rootCollection = {
+      getField: vi.fn(() => null),
+      getFields: () => [],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-legacy-profile-nickname',
+        enable: true,
+        targetPath: 'legacyProfile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[configuredParent]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(rootCollection.getField).toHaveBeenCalled();
+      expect(configuredParent.isLeaf).toBe(false);
+    });
+  });
+
+  it('preloads the latest fieldOptions after props switch', async () => {
+    const nameField = { name: 'name', title: 'Name', interface: 'input' };
+    const nicknameField = { name: 'nickname', title: 'Nickname', interface: 'input' };
+    const profileCollection = {
+      getField: (name: string) => {
+        if (name === 'name') return nameField;
+        if (name === 'nickname') return nicknameField;
+        return null;
+      },
+      getFields: vi.fn(() => [nameField, nicknameField]),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const oldConfiguredParent = {
+      label: 'Profile',
+      value: 'profile',
+      isLeaf: false,
+      children: [{ label: 'Name', value: 'name', isLeaf: true }],
+    };
+    const latestConfiguredParent = {
+      label: 'Profile',
+      value: 'profile',
+      isLeaf: false,
+      children: [{ label: 'Name', value: 'name', isLeaf: true }],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    const { container, rerender } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[oldConfiguredParent]}
+          rootCollection={rootCollection}
+          value={[]}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    rerender(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[latestConfiguredParent]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(profileCollection.getFields).toHaveBeenCalled();
+    });
+    const selector = container.querySelector('.ant-select-selector') as HTMLElement | null;
+    expect(selector).not.toBeNull();
+    await userEvent.click(selector as HTMLElement);
+    expect(await screen.findByText('Nickname')).toBeInTheDocument();
+  });
+
+  it('does not mutate fieldOptions props while preloading children', async () => {
+    const nameField = { name: 'name', title: 'Name', interface: 'input' };
+    const nicknameField = { name: 'nickname', title: 'Nickname', interface: 'input' };
+    const profileCollection = {
+      getField: (name: string) => {
+        if (name === 'name') return nameField;
+        if (name === 'nickname') return nicknameField;
+        return null;
+      },
+      getFields: vi.fn(() => [nameField, nicknameField]),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const configuredParent = {
+      label: 'Profile',
+      value: 'profile',
+      isLeaf: false,
+      children: [{ label: 'Name', value: 'name', isLeaf: true }],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[configuredParent]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(profileCollection.getFields).toHaveBeenCalled();
+    });
+    expect(configuredParent.children.some((child) => child.value === 'nickname')).toBe(false);
+  });
+
+  it('retries preload when rootCollection becomes resolvable with same fieldOptions', async () => {
+    const nicknameField = { name: 'nickname', title: 'Nickname', interface: 'input' };
+    const profileCollection = {
+      getField: (name: string) => (name === 'nickname' ? nicknameField : null),
+      getFields: vi.fn(() => [nicknameField]),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const unresolvedCollection = {
+      getField: () => null,
+      getFields: () => [],
+    };
+    const resolvedCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const configuredParent = {
+      label: 'Profile',
+      value: 'profile',
+      isLeaf: false,
+      children: [{ label: 'Name', value: 'name', isLeaf: true }],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+
+    const { rerender } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[configuredParent]}
+          rootCollection={unresolvedCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    rerender(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[configuredParent]}
+          rootCollection={resolvedCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await waitFor(() => {
+      expect(profileCollection.getFields).toHaveBeenCalled();
+    });
+  });
+
+  it('handles preload errors without leaving unhandled rejections', async () => {
+    const loadError = new Error('failed to load fields');
+    const profileCollection = {
+      getFields: vi.fn(() => {
+        throw loadError;
+      }),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const configuredParent = {
+      label: 'Profile',
+      value: 'profile',
+      isLeaf: false,
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile-nickname',
+        enable: true,
+        targetPath: 'profile.nickname',
+        mode: 'assign',
+      },
+    ];
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[configuredParent]}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    try {
+      await waitFor(() => {
+        expect(warnSpy).toHaveBeenCalledWith('[FieldAssignRulesEditor] Failed to preload cascader path', loadError);
+      });
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('keeps loaded cascader children when translation function identity changes', async () => {
+    const nameField = { name: 'name', title: 'Name', interface: 'input' };
+    const nicknameField = { name: 'nickname', title: 'Nickname', interface: 'input' };
+    const profileCollection = {
+      getField: (name: string) => {
+        if (name === 'name') return nameField;
+        if (name === 'nickname') return nicknameField;
+        return null;
+      },
+      getFields: vi.fn(() => [nameField, nicknameField]),
+    };
+    const profileField = {
+      name: 'profile',
+      title: 'Profile',
+      type: 'belongsTo',
+      interface: 'm2o',
+      target: 'profiles',
+      targetCollection: profileCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'profile' ? profileField : null),
+      getFields: () => [profileField],
+    };
+    const fieldOptions = [
+      {
+        label: 'Profile',
+        value: 'profile',
+        isLeaf: false,
+      },
+    ];
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-profile',
+        enable: true,
+        targetPath: 'profile',
+        mode: 'assign',
+      },
+    ];
+
+    const { container, rerender } = render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={(key) => key}
+          fieldOptions={fieldOptions}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    const selector = container.querySelector('.ant-select-selector') as HTMLElement | null;
+    expect(selector).not.toBeNull();
+    await userEvent.click(selector as HTMLElement);
+    const profileOption = (await screen.findAllByText('Profile')).find((item) =>
+      item.closest('.ant-cascader-menu-item'),
+    );
+    expect(profileOption).toBeTruthy();
+    await userEvent.click(profileOption as HTMLElement);
+    expect(await screen.findByText('Nickname')).toBeInTheDocument();
+    await userEvent.keyboard('{Escape}');
+
+    rerender(
+      wrap(
+        <FieldAssignRulesEditor
+          t={(key) => key}
+          fieldOptions={fieldOptions}
+          rootCollection={rootCollection}
+          value={value}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await userEvent.click(selector as HTMLElement);
+    expect(await screen.findByText('Nickname')).toBeInTheDocument();
+  });
+
   it('saves selected title field into current assign rule without syncing', async () => {
     const { rootCollection, value } = createAssociationFixture();
     const onChange = vi.fn();

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

@@ -14,6 +14,15 @@ import {
   collectFieldAssignCascaderOptions,
 } from '../fieldAssignOptions';
 
+type TestCollectionField = {
+  name?: string;
+  title?: string;
+  interface?: string;
+  target?: string;
+  targetCollection?: unknown;
+  isAssociationField?: () => boolean;
+};
+
 describe('fieldAssignOptions', () => {
   it('marks subform node as non-leaf so Cascader can lazy-load target collection fields', () => {
     const usersCollection = {
@@ -98,8 +107,58 @@ describe('fieldAssignOptions', () => {
     ).toBe(true);
   });
 
+  it('preserves configured display association field paths as nested cascader options', () => {
+    const orgNameField = {
+      name: 'orgname',
+      title: '公司名称(单行文本)',
+      interface: 'input',
+      type: 'string',
+      isAssociationField: () => false,
+    };
+    const orgCollection = {
+      getFields: () => [orgNameField],
+      getField: (name: string) => (name === 'orgname' ? orgNameField : null),
+    };
+    const orgAssociationField = {
+      name: 'org_m2o',
+      title: 'org_m2o',
+      interface: 'm2o',
+      type: 'belongsTo',
+      target: 'org',
+      isAssociationField: () => true,
+      targetCollection: orgCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'org_m2o' ? orgAssociationField : null),
+      getFields: () => [orgAssociationField],
+    };
+    const displayAssociationItemModel = {
+      props: { label: '公司名称(单行文本)' },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'org_m2o.orgname' };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: orgNameField },
+        },
+      },
+    };
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: { grid: { subModels: { items: [displayAssociationItemModel] } } },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const orgOption = options.find((option) => option.value === 'org_m2o');
+
+    expect(orgOption?.isLeaf).toBe(false);
+    expect(orgOption?.children?.some((child) => child.value === 'orgname' && child.isLeaf === true)).toBe(true);
+    expect(options.some((option) => option.value === 'orgname')).toBe(false);
+  });
+
   it('hides configured association fields deeper than relation / relation / field', () => {
-    const makeItem = (fieldPath: string, field: any, label: string) => ({
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
       props: { label },
       getStepParams: (flowKey: string, stepKey: string) => {
         if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
@@ -141,9 +200,98 @@ describe('fieldAssignOptions', () => {
     };
 
     const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
+
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
+  });
+
+  it('hides configured non-association fields under a third association level', () => {
+    const codeField = {
+      name: 'code',
+      title: 'Code',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const companyCollection = {
+      getField: (name: string) => (name === 'code' ? codeField : null),
+      getFields: () => [codeField],
+    };
+    const companyField = {
+      name: 'company',
+      title: 'Company',
+      interface: 'm2o',
+      target: 'companies',
+      isAssociationField: () => true,
+      targetCollection: companyCollection,
+    };
+    const nameField = {
+      name: 'name',
+      title: 'Name',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const departmentCollection = {
+      getField: (name: string) => (name === 'name' ? nameField : name === 'company' ? companyField : null),
+      getFields: () => [nameField, companyField],
+    };
+    const departmentField = {
+      name: 'department',
+      title: 'Department',
+      interface: 'm2o',
+      target: 'departments',
+      isAssociationField: () => true,
+      targetCollection: departmentCollection,
+    };
+    const userCollection = {
+      getField: (name: string) => (name === 'department' ? departmentField : null),
+      getFields: () => [departmentField],
+    };
+    const usersField = {
+      name: 'users',
+      title: 'Users',
+      interface: 'm2m',
+      target: 'users',
+      isAssociationField: () => true,
+      targetCollection: userCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'users' ? usersField : null),
+      getFields: () => [usersField],
+    };
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
+      props: { label },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: field },
+        },
+      },
+    });
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: {
+        grid: {
+          subModels: {
+            items: [
+              makeItem('users.department.name', nameField, 'Department name'),
+              makeItem('users.department.company.code', codeField, 'Company code'),
+            ],
+          },
+        },
+      },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
 
-    expect(options.map((item) => item.value)).toContain('name');
-    expect(options.map((item) => item.value)).not.toContain('company');
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
   });
 
   it('hides lazy-loaded association selector options after two association levels', () => {