@nocobase/client-v2 2.1.9 → 2.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.9",
+  "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.9",
-    "@nocobase/flow-engine": "2.1.9",
-    "@nocobase/sdk": "2.1.9",
-    "@nocobase/shared": "2.1.9",
-    "@nocobase/utils": "2.1.9",
+    "@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": "2b612d81c6f6115af75ea7b279384751af869510"
+  "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/actions/validation.tsx

@@ -10,6 +10,56 @@
 import { defineAction, jioToJoiSchema, tExpr } from '@nocobase/flow-engine';
 import { FieldValidation } from '../../flow-compat';
 
+type ValidationType = 'string' | 'number' | 'array' | 'boolean' | 'any';
+
+interface ValidationRule {
+  name: string;
+  args?: any;
+}
+
+interface ValidationData {
+  type: ValidationType;
+  rules?: ValidationRule[];
+}
+
+interface ValidationContext {
+  model: {
+    props: {
+      label?: string;
+    };
+  };
+  t: (key: string, options?: Record<string, unknown>) => string;
+}
+
+function buildValidationRules(ctx: ValidationContext, validation: ValidationData) {
+  const rules = [];
+  const schema = jioToJoiSchema(validation);
+  const label = ctx.model.props.label;
+  rules.push({
+    validator: (_: unknown, value: unknown) => {
+      const { error } = schema.validate(value, {
+        abortEarly: false,
+      });
+
+      if (error) {
+        const messages = error.details.map((d: { type: string; context?: Record<string, unknown> }) => {
+          return ctx.t(`${d.type}`, {
+            ...d.context,
+            ns: 'data-source-main',
+            label,
+          });
+        });
+        const div = document.createElement('div');
+        div.innerHTML = messages.join('; ');
+        return Promise.reject(div.textContent);
+      }
+
+      return Promise.resolve();
+    },
+  });
+  return rules;
+}
+
 export const validation = defineAction({
   title: tExpr('Validation'),
   name: 'validation',
@@ -29,6 +79,7 @@ export const validation = defineAction({
           type: targetInterface.validationType,
           availableValidationOptions: [...new Set(targetInterface.availableValidationOptions)],
           excludeValidationOptions: [...new Set(targetInterface.excludeValidationOptions)],
+          inheritedValue: ctx.model.collectionField.validation,
           isAssociation: targetInterface.isAssociation,
         },
       },
@@ -36,40 +87,21 @@ export const validation = defineAction({
   },
   handler(ctx, params) {
     if (params.validation) {
-      const rules = [];
-      const schema = jioToJoiSchema(params.validation);
-      const label = ctx.model.props.label;
-      rules.push({
-        validator: (_, value) => {
-          const { error } = schema.validate(value, {
-            abortEarly: false,
-          });
-
-          if (error) {
-            const messages = error.details.map((d) => {
-              return ctx.t(`${d.type}`, {
-                ...d.context,
-                ns: 'data-source-main',
-                label,
-              });
-            });
-            const div = document.createElement('div');
-            div.innerHTML = messages.join('; ');
-            return Promise.reject(div.textContent);
-          }
-
-          return Promise.resolve();
-        },
-      });
-      const hasRequiredInCollection = params.validation.rules.some((rule) => rule.name === 'required');
-      if (hasRequiredInCollection) {
+      const collectionValidation = ctx.model.collectionField?.validation;
+      const collectionRules = ctx.model.collectionField?.getComponentProps?.().rules || [];
+      const uiRules = params.validation.rules?.length
+        ? buildValidationRules(ctx as unknown as ValidationContext, params.validation)
+        : [];
+      const hasRequiredInValidation = [collectionValidation, params.validation].some(
+        (validation) => validation?.rules?.some((rule) => rule.name === 'required'),
+      );
+      if (hasRequiredInValidation) {
         ctx.model.setProps({
-          required: hasRequiredInCollection,
+          required: hasRequiredInValidation,
         });
       }
-      console.log(rules);
       ctx.model.setProps({
-        rules,
+        rules: [...collectionRules, ...uiRules],
         validation: params.validation,
       });
     }

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;
     };