@nocobase/client-v2 2.1.10 → 2.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.10",
-    "@nocobase/flow-engine": "2.1.10",
-    "@nocobase/sdk": "2.1.10",
-    "@nocobase/shared": "2.1.10",
-    "@nocobase/utils": "2.1.10",
+    "@nocobase/evaluators": "2.1.11",
+    "@nocobase/flow-engine": "2.1.11",
+    "@nocobase/sdk": "2.1.11",
+    "@nocobase/shared": "2.1.11",
+    "@nocobase/utils": "2.1.11",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "65d5bc38d72d5a6fca8bcf9798a0b976e382cac9"
+  "gitHead": "1ccf891d837e21089f65f84b892407b34a0a0cb9"
 }

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -139,6 +139,64 @@ describe('normalizeDataScopeFilter', () => {
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
 
+  it('dataScope handler preserves current role as server-side variable', async () => {
+    const engine = new FlowEngine();
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = engine.context;
+    ctx.defineProperty('api', { value: { auth: { role: '__union__' } } });
+    ctx.defineProperty('user', {
+      value: {
+        roles: [{ name: 'admin' }, { name: 'member' }],
+      },
+    });
+    ctx.defineProperty('model', {
+      value: {
+        uid: 'table-1',
+        resource,
+      },
+    });
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'roles.name', operator: '$includes', value: '{{ ctx.role }}' }],
+      },
+    };
+
+    await (dataScope as { handler: (ctx: typeof ctx, params: typeof params) => Promise<void> }).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('table-1', {
+      $and: [{ roles: { name: { $includes: '{{$nRole}}' } } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler preserves current role as server-side variable', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { resolvedValue: ['admin', 'member'] });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'roles.name', operator: '$includes', value: '{{ctx.role}}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ roles: { name: { $includes: '{{$nRole}}' } } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
   it('setTargetDataScope handler sends null for empty variable dependencies', async () => {
     const resource = {
       addFilterGroup: vi.fn(),

package/src/flow/actions/dataScopeFilter.ts

@@ -12,6 +12,12 @@ import { transformFilter } from '@nocobase/utils/client';
 import _ from 'lodash';
 
 const PRESERVE_NULL = { __nocobaseDataScopeNull__: true };
+const SERVER_CURRENT_ROLE_VARIABLE = '{{$nRole}}';
+const CURRENT_ROLE_EXPRESSION_RE = /^\s*\{\{\s*ctx\.role\s*\}\}\s*$/;
+
+function isCurrentRoleExpression(value: unknown) {
+  return typeof value === 'string' && CURRENT_ROLE_EXPRESSION_RE.test(value);
+}
 
 function isPreserveNull(value: any) {
   return (
@@ -45,6 +51,10 @@ function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
   }
 
   if ('path' in rawNode && 'operator' in rawNode) {
+    if (isCurrentRoleExpression(rawNode.value)) {
+      resolvedNode.value = SERVER_CURRENT_ROLE_VARIABLE;
+      return;
+    }
     if (
       isVariableExpression(rawNode.value) &&
       (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')

package/src/flow/components/FieldAssignRulesEditor.tsx

@@ -113,6 +113,48 @@ export interface FieldAssignRulesEditorProps {
 
 const ALL_ASSIGN_MODES: AssignMode[] = ['default', 'override', 'assign'];
 
+function cloneCascaderOption(option: FieldAssignCascaderOption): FieldAssignCascaderOption {
+  return {
+    ...option,
+    children: option.children?.map((child) => cloneCascaderOption(child)),
+  };
+}
+
+function mergeCascaderOptionInto(options: FieldAssignCascaderOption[], source: FieldAssignCascaderOption) {
+  const value = source?.value ? String(source.value) : '';
+  if (!value) return;
+
+  const existing = options.find((item) => String(item?.value || '') === value);
+  if (!existing) {
+    options.push(cloneCascaderOption(source));
+    return;
+  }
+
+  if (!existing.label && source.label) {
+    existing.label = source.label;
+  }
+  if (source.isLeaf === false || existing.children?.length || source.children?.length) {
+    existing.isLeaf = false;
+  }
+  if (source.loading) {
+    existing.loading = source.loading;
+  }
+  if (source.children?.length) {
+    existing.children = mergeCascaderOptions(existing.children || [], source.children);
+  }
+}
+
+function mergeCascaderOptions(
+  configured: FieldAssignCascaderOption[],
+  allFields: FieldAssignCascaderOption[],
+): FieldAssignCascaderOption[] {
+  const result = (Array.isArray(configured) ? configured : []).map((item) => cloneCascaderOption(item));
+  for (const item of Array.isArray(allFields) ? allFields : []) {
+    mergeCascaderOptionInto(result, item);
+  }
+  return result;
+}
+
 function isAssignMode(mode: unknown): mode is AssignMode {
   return mode === 'default' || mode === 'override' || mode === 'assign';
 }
@@ -171,13 +213,21 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
     },
     [normalizeItemMode, onChange],
   );
+
+  const normalizeFieldOptions = React.useCallback((options: FieldAssignRulesEditorProps['fieldOptions']) => {
+    return Array.isArray(options)
+      ? (options as FieldAssignCascaderOption[]).map((option) => cloneCascaderOption(option))
+      : [];
+  }, []);
   const [cascaderOptions, setCascaderOptions] = React.useState<FieldAssignCascaderOption[]>(() =>
-    Array.isArray(fieldOptions) ? (fieldOptions as FieldAssignCascaderOption[]) : [],
+    normalizeFieldOptions(fieldOptions),
   );
+  const loadedCascaderOptionsRef = React.useRef<WeakSet<FieldAssignCascaderOption>>(new WeakSet());
 
   React.useEffect(() => {
-    setCascaderOptions(Array.isArray(fieldOptions) ? (fieldOptions as FieldAssignCascaderOption[]) : []);
-  }, [fieldOptions]);
+    loadedCascaderOptionsRef.current = new WeakSet();
+    setCascaderOptions(normalizeFieldOptions(fieldOptions));
+  }, [fieldOptions, normalizeFieldOptions, rootCollection, maxAssociationFieldDepth]);
 
   const getRuleKey = React.useCallback((item: FieldAssignRuleItem, index: number) => item?.key || String(index), []);
   const [titleFieldDraftMap, setTitleFieldDraftMap] = React.useState<Record<string, string | undefined>>({});
@@ -597,23 +647,26 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
       const opts = selectedOptions || [];
       const target = opts[opts.length - 1];
       if (!target) return;
-      if (target.children && Array.isArray(target.children) && target.children.length) return;
       if (target.isLeaf) return;
+      if (loadedCascaderOptionsRef.current.has(target)) return;
 
       const segments = opts.map((o) => String(o?.value)).filter(Boolean);
       const targetCollection = resolveTargetCollectionBySegments(segments);
       if (!targetCollection) {
-        target.isLeaf = true;
+        target.isLeaf = !(target.children && target.children.length);
+        loadedCascaderOptionsRef.current.add(target);
         setCascaderOptions((prev) => [...prev]);
         return;
       }
 
       const children = buildChildrenFromCollection(targetCollection, segments.length);
       if (!children.length) {
-        target.isLeaf = true;
+        target.isLeaf = !(target.children && target.children.length);
       } else {
-        target.children = children;
+        target.children = mergeCascaderOptions(target.children || [], children);
+        target.isLeaf = false;
       }
+      loadedCascaderOptionsRef.current.add(target);
       setCascaderOptions((prev) => [...prev]);
     },
     [buildChildrenFromCollection, resolveTargetCollectionBySegments],
@@ -629,12 +682,14 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
         const hit = options.find((o) => String(o?.value) === seg);
         if (!hit) return;
         selected.push(hit);
+        if (!hit.isLeaf && !loadedCascaderOptionsRef.current.has(hit)) {
+          await loadCascaderData(selected);
+        }
         if (hit.children?.length) {
           options = hit.children;
           continue;
         }
         if (hit.isLeaf) return;
-        await loadCascaderData(selected);
         options = hit.children || [];
       }
     },
@@ -665,7 +720,9 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
         await preloadCascaderPath(segs);
       }
     };
-    void run();
+    run().catch((error) => {
+      console.warn('[FieldAssignRulesEditor] Failed to preload cascader path', error);
+    });
     return () => {
       cancelled = true;
     };

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();