@nocobase/client-v2 2.2.0-beta.3 → 2.2.0-beta.6

package/src/flow/actions/linkageRules.tsx

@@ -16,13 +16,9 @@ import {
   FlowRuntimeContext,
   useFlowContext,
   useFlowEngine,
-  createSafeWindow,
-  createSafeDocument,
-  createSafeNavigator,
   observer,
   isRunJSValue,
   normalizeRunJSValue,
-  runjsWithSafeGlobals,
 } from '@nocobase/flow-engine';
 import { evaluateConditions, FilterGroupType, removeInvalidFilterItems } from '@nocobase/utils/client';
 import React from 'react';
@@ -40,7 +36,7 @@ import { FilterGroup } from '../components/filter/FilterGroup';
 import { LinkageFilterItem } from '../components/filter';
 import { CodeEditor } from '../components/code-editor';
 import { FieldAssignRulesEditor } from '../components/FieldAssignRulesEditor';
-import type { FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
+import type { AssignMode, FieldAssignRuleItem } from '../components/FieldAssignRulesEditor';
 import { collectFieldAssignCascaderOptions } from '../components/fieldAssignOptions';
 import { useAssociationTitleFieldSync } from '../components/useAssociationTitleFieldSync';
 import _ from 'lodash';
@@ -492,7 +488,7 @@ async function resolveLinkageAssignRuntimeValue(ctx: FlowContext, rawValue: any)
 
   try {
     const { code, version } = normalizeRunJSValue(rawValue);
-    const ret = await runjsWithSafeGlobals(ctx, code, { version });
+    const ret = await ctx.runjs(code, undefined, { version });
     if (!ret?.success) {
       return SKIP_RUNJS_ASSIGN_VALUE;
     }
@@ -888,6 +884,20 @@ type ArrayFieldComponentProps = {
 
 const LEGACY_ASSIGN_RULE = { mode: 'assign', valueKey: 'assignValue' } as const;
 const LEGACY_DEFAULT_RULE = { mode: 'default', valueKey: 'initialValue' } as const;
+const LINKAGE_ASSIGN_MODE_PROP = '__linkageAssignMode';
+
+function normalizeLinkageAssignMode(mode: unknown): AssignMode {
+  if (mode === 'default') return 'default';
+  if (mode === 'override') return 'override';
+  return 'assign';
+}
+
+type LinkageValuePatch = {
+  path: Array<string | number>;
+  value: unknown;
+  whenEmpty?: boolean;
+  mode?: AssignMode;
+};
 
 const FieldAssignRulesActionComponent: React.FC<
   ArrayFieldComponentProps & {
@@ -1002,16 +1012,24 @@ export const linkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         if (fieldModel) {
           if (mode === 'default') {
             setProps(fieldModel as FlowModel, { initialValue: finalValue });
           } else {
-            setProps(fieldModel as FlowModel, { value: finalValue });
+            setProps(fieldModel as FlowModel, {
+              value: finalValue,
+              ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+            });
           }
         } else if (typeof addFormValuePatch === 'function') {
           // 对关联字段子属性（如 user.name）等没有独立 FormItemModel 的目标，直接写入表单值
-          addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+          addFormValuePatch({
+            path: targetPath,
+            value: finalValue,
+            whenEmpty: mode === 'default',
+            ...(mode === 'override' ? { mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1177,7 +1195,7 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
-        const mode = it?.mode === 'default' ? 'default' : 'assign';
+        const mode = normalizeLinkageAssignMode(it?.mode);
         const actionName = (ctx.model as any)?.getAclActionName?.() ?? (ctx.model as any)?.context?.actionName;
         const isEditForm = actionName === 'update';
         const isNewItem = (ctx as any)?.item?.__is_new__ === true;
@@ -1207,12 +1225,21 @@ export const subFormLinkageAssignField = defineAction({
           continue;
         }
 
+        if (mode === 'override' && hasExplicitPathHit(targetPath)) {
+          continue;
+        }
+
         if (!fieldUid) {
           if (mode === 'default' && hasExplicitPathHit(targetPath)) {
             continue;
           }
           if (typeof addFormValuePatch === 'function') {
-            addFormValuePatch({ path: targetPath, value: finalValue, whenEmpty: mode === 'default' });
+            addFormValuePatch({
+              path: targetPath,
+              value: finalValue,
+              whenEmpty: mode === 'default',
+              ...(mode === 'override' ? { mode } : {}),
+            });
           }
           continue;
         }
@@ -1223,7 +1250,10 @@ export const subFormLinkageAssignField = defineAction({
         if (mode === 'default') {
           setProps(model, { initialValue: finalValue });
         } else {
-          setProps(model, { value: finalValue });
+          setProps(model, {
+            value: finalValue,
+            ...(mode === 'override' ? { [LINKAGE_ASSIGN_MODE_PROP]: mode } : {}),
+          });
         }
       }
     } catch (error) {
@@ -1363,8 +1393,7 @@ export const linkageRunjs = defineAction({
     }
 
     try {
-      const navigator = createSafeNavigator();
-      await ctx.runjs(script, { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator });
+      await ctx.runjs(script);
     } catch (error) {
       console.error('Script execution error:', error);
       // 可以选择显示错误信息给用户
@@ -1781,7 +1810,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const modelsToApply = new Set<FlowModel>(allModels);
   const patchPropsByModel = new Map<FlowModel, any>();
   const clearValueOnHiddenModelUids = new Set<string>();
-  const directValuePatches: Array<{ path: Array<string | number>; value: any; whenEmpty?: boolean }> = [];
+  const directValuePatches: LinkageValuePatch[] = [];
   const rootCollection = getCollectionFromModel((ctx.model as any)?.context?.blockModel ?? ctx.model);
   const isSafeToWriteAssociationSubpath = (namePath: any): boolean => {
     if (!Array.isArray(namePath) || !namePath.length) return true;
@@ -1836,13 +1865,18 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     }
 
     for (const patch of lastPatchByPathKey.values()) {
-      if (!patch.whenEmpty) continue;
+      if (!patch.whenEmpty && patch.mode !== 'default') continue;
       runtime.recordDefaultValuePatch(patch.path, patch.value);
     }
   };
-  const addFormValuePatch = (patch: { path: any; value: any; whenEmpty?: boolean }) => {
+  const getPatchMode = (patch: { mode?: unknown; whenEmpty?: boolean }): AssignMode => {
+    if (patch?.mode === 'default') return 'default';
+    if (patch?.mode === 'override') return 'override';
+    return patch?.whenEmpty ? 'default' : 'assign';
+  };
+  const addFormValuePatch = (patch: { path: unknown; value: unknown; whenEmpty?: boolean; mode?: AssignMode }) => {
     if (!patch) return;
-    const path = (patch as any)?.path;
+    const path = patch.path;
     if (!path) return;
     const resolvedPath = resolveNamePathForPatch(path);
     if (!resolvedPath) {
@@ -1862,8 +1896,9 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       });
       return;
     }
-    const whenEmpty = !!(patch as any)?.whenEmpty;
-    const value = (patch as any)?.value;
+    const mode = getPatchMode(patch);
+    const whenEmpty = mode === 'default';
+    const value = patch.value;
     try {
       const form = ctx.model?.context?.form;
       const current = form?.getFieldValue?.(resolvedPath);
@@ -1878,6 +1913,15 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           return;
         }
       }
+      if (mode === 'override') {
+        const runtime = getDefaultPatchRuntime();
+        if (
+          typeof runtime?.canApplyOverrideValuePatch === 'function' &&
+          !runtime.canApplyOverrideValuePatch(resolvedPath)
+        ) {
+          return;
+        }
+      }
       if (_.isEqual(current, value)) {
         return;
       }
@@ -1889,6 +1933,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       path: resolvedPath,
       value,
       ...(whenEmpty ? { whenEmpty: true } : {}),
+      ...(mode === 'override' ? { mode } : {}),
     });
   };
   const removePendingFormValuePatches = (path: any) => {
@@ -1948,6 +1993,21 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     >;
     return normalized.length ? normalized : null;
   };
+  const pathKeysEqual = (
+    a: Array<string | number> | null | undefined,
+    b: Array<string | number> | null | undefined,
+  ) => {
+    if (!a || !b) return false;
+    return namePathToPathKey(a) === namePathToPathKey(b);
+  };
+  const namePathEndsWith = (
+    namePath: Array<string | number> | null | undefined,
+    suffix: Array<string | number> | null | undefined,
+  ) => {
+    if (!namePath || !suffix || suffix.length > namePath.length) return false;
+    const offset = namePath.length - suffix.length;
+    return suffix.every((seg, index) => namePath[offset + index] === seg);
+  };
   const getFieldIndexEntries = (fieldIndex: any): Array<{ name: string; index: number }> => {
     if (!Array.isArray(fieldIndex)) return [];
     return fieldIndex
@@ -1996,17 +2056,35 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     return out;
   };
+  const getTrustedFieldPathArray = (
+    fieldPathArray: Array<string | number> | null,
+    targetPath: string | null,
+    fieldIndex: unknown,
+  ): Array<string | number> | null => {
+    if (!fieldPathArray || !targetPath) return null;
+
+    const targetNamePath = normalizeNamePathForKey(
+      parsePathString(targetPath).filter((seg) => typeof seg === 'string' || typeof seg === 'number'),
+    );
+    const resolvedTargetPath = normalizeNamePathForKey(resolveDynamicNamePath(targetPath, fieldIndex));
+    const indexedRelativePath = resolveIndexedRelativePath(targetPath, fieldIndex);
+
+    if (
+      pathKeysEqual(fieldPathArray, resolvedTargetPath) ||
+      pathKeysEqual(fieldPathArray, indexedRelativePath) ||
+      namePathEndsWith(fieldPathArray, targetNamePath)
+    ) {
+      return fieldPathArray;
+    }
+
+    return null;
+  };
   const getModelTargetPathForHiddenClear = (model: any): string | Array<string | number> | null => {
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
     const targetPath = getModelTargetPathForPatch(model);
-    if (fieldPathArray) {
-      const targetPathLastString = targetPath
-        ? ([...parsePathString(targetPath)].reverse().find((seg) => typeof seg === 'string') as string | undefined)
-        : undefined;
-      const fieldPathArrayLastString = [...fieldPathArray].reverse().find((seg) => typeof seg === 'string');
-      if (!targetPathLastString || targetPathLastString === fieldPathArrayLastString) {
-        return fieldPathArray;
-      }
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      return trustedFieldPathArray;
     }
 
     if (!targetPath) return null;
@@ -2016,12 +2094,13 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const getModelTargetPathKeys = (model: any): Set<string> => {
     const keys = new Set<string>();
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
-    if (fieldPathArray) {
-      keys.add(namePathToPathKey(fieldPathArray));
+    const targetPath = getModelTargetPathForPatch(model);
+    const trustedFieldPathArray = getTrustedFieldPathArray(fieldPathArray, targetPath, model?.context?.fieldIndex);
+    if (trustedFieldPathArray) {
+      keys.add(namePathToPathKey(trustedFieldPathArray));
       return keys;
     }
 
-    const targetPath = getModelTargetPathForPatch(model);
     if (targetPath) {
       const fieldIndexEntries = getFieldIndexEntries(model?.context?.fieldIndex);
       if (!fieldIndexEntries.length) {
@@ -2082,6 +2161,14 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     for (const action of actions) {
       const setProps = (model: FlowModel & { __originalProps?: any; __shouldReset?: boolean }, props: any) => {
+        const normalizedProps =
+          props && typeof props === 'object' && Object.prototype.hasOwnProperty.call(props, 'value')
+            ? {
+                ...props,
+                [LINKAGE_ASSIGN_MODE_PROP]: normalizeLinkageAssignMode(props?.[LINKAGE_ASSIGN_MODE_PROP]),
+              }
+            : props;
+
         // 存储原始值，用于恢复
         if (!model.__originalProps) {
           model.__originalProps = {
@@ -2097,7 +2184,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
         // 临时存起来，遍历完所有规则后，再统一处理
         patchPropsByModel.set(model, {
           ...(patchPropsByModel.get(model) || {}),
-          ...props,
+          ...normalizedProps,
         });
 
         if (
@@ -2151,7 +2238,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     const prevHidden = !!model.hidden;
     const nextHidden = !!newProps.hiddenModel;
 
-    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
+    model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText', LINKAGE_ASSIGN_MODE_PROP]));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(nextHidden);
@@ -2190,7 +2277,8 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           targetUid: model?.uid,
         });
       } else {
-        addFormValuePatch({ path: targetPath, value: newProps.value });
+        const mode = normalizeLinkageAssignMode(patchProps?.[LINKAGE_ASSIGN_MODE_PROP]);
+        addFormValuePatch({ path: targetPath, value: newProps.value, ...(mode === 'override' ? { mode } : {}) });
       }
     }
 

package/src/flow/actions/runjs.tsx

@@ -7,14 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import {
-  ActionScene,
-  defineAction,
-  tExpr,
-  createSafeWindow,
-  createSafeDocument,
-  createSafeNavigator,
-} from '@nocobase/flow-engine';
+import { ActionScene, defineAction, tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../components/code-editor';
 
 export const runjs = defineAction({
@@ -38,11 +31,6 @@ export const runjs = defineAction({
     // 如果是 URL 触发的，则不执行代码
     if (ctx.inputArgs?.navigation) return;
 
-    const navigator = createSafeNavigator();
-    return ctx.runjs(params.code, {
-      window: createSafeWindow({ navigator }),
-      document: createSafeDocument(),
-      navigator,
-    });
+    return ctx.runjs(params.code);
   },
 });

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/admin-shell/admin-layout/AdminLayoutComponent.tsx

@@ -42,6 +42,7 @@ import {
   FLOW_SETTINGS_PREFERENCE_STORAGE_KEY,
   readFlowSettingsPreference,
 } from './flowSettingsPreference';
+import { joinAdminLayoutRoutePath, type AdminLayoutRoutePathLike } from './resolveAdminRouteRuntimeTarget';
 import { useAppListRender } from './AppListRender';
 
 const className1 = css`
@@ -314,25 +315,37 @@ const DesignerButtonMenuItem: FC<{ item: AdminLayoutMenuNode; fallbackParentRout
   );
 };
 
-const matchesRoutePath = (route: NocoBaseDesktopRoute | undefined, pathname: string): boolean => {
+const matchesRoutePath = (
+  route: NocoBaseDesktopRoute | undefined,
+  pathname: string,
+  layout?: AdminLayoutRoutePathLike | null,
+): boolean => {
   if (!route) {
     return false;
   }
 
   const candidates = [
-    route.id != null ? `/admin/${route.id}` : null,
-    route.schemaUid ? `/admin/${route.schemaUid}` : null,
+    route.id != null ? joinAdminLayoutRoutePath(layout, route.id) : null,
+    route.schemaUid ? joinAdminLayoutRoutePath(layout, route.schemaUid) : null,
   ].filter(Boolean) as string[];
 
   if (candidates.some((candidate) => pathname === candidate || pathname.startsWith(`${candidate}/`))) {
     return true;
   }
 
-  return Array.isArray(route.children) ? route.children.some((child) => matchesRoutePath(child, pathname)) : false;
+  return Array.isArray(route.children)
+    ? route.children.some((child) => matchesRoutePath(child, pathname, layout))
+    : false;
 };
 
-const findSelectedTopGroupRoute = (routes: NocoBaseDesktopRoute[], pathname: string) => {
-  return routes.find((route) => route.type === NocoBaseDesktopRouteType.group && matchesRoutePath(route, pathname));
+const findSelectedTopGroupRoute = (
+  routes: NocoBaseDesktopRoute[],
+  pathname: string,
+  layout?: AdminLayoutRoutePathLike | null,
+) => {
+  return routes.find(
+    (route) => route.type === NocoBaseDesktopRouteType.group && matchesRoutePath(route, pathname, layout),
+  );
 };
 
 const renderMenuNodeWithModel = (
@@ -376,6 +389,11 @@ export const AdminLayoutComponent = observer((props: any) => {
   const { token } = antdTheme.useToken();
   const customToken = token as CustomToken;
   const isMobileLayout = !!adminLayoutModel?.isMobileLayout;
+  const adminLayoutRoutePath = adminLayoutModel?.layout?.routePath;
+  const adminLayoutRoutePathLike = useMemo<AdminLayoutRoutePathLike | undefined>(
+    () => (adminLayoutRoutePath ? { routePath: adminLayoutRoutePath } : undefined),
+    [adminLayoutRoutePath],
+  );
   const menuRouteRefreshVersion = adminLayoutModel?.menuRouteRefreshVersion || 0;
   const isMobileSider = isMobileLayout;
   const [collapsed, setCollapsed] = useState(isMobileSider);
@@ -403,8 +421,8 @@ export const AdminLayoutComponent = observer((props: any) => {
     [adminLayoutModel],
   );
   const selectedTopGroupRoute = useMemo(
-    () => findSelectedTopGroupRoute(allAccessRoutes, location.pathname),
-    [allAccessRoutes, location.pathname],
+    () => findSelectedTopGroupRoute(allAccessRoutes, location.pathname, adminLayoutRoutePathLike),
+    [adminLayoutRoutePathLike, allAccessRoutes, location.pathname],
   );
 
   const handleMenuDragEnd = useCallback(
@@ -458,6 +476,7 @@ export const AdminLayoutComponent = observer((props: any) => {
 
   useEffect(() => {
     const routeRepository = flowEngine.context.routeRepository;
+    const deactivateLayout = routeRepository?.activateLayout?.(adminLayoutModel?.layout);
     const subscriber = () => {
       const updatedRoutes = routeRepository?.listAccessible() || [];
       setAllAccessRoutes(updatedRoutes);
@@ -470,8 +489,9 @@ export const AdminLayoutComponent = observer((props: any) => {
 
     return () => {
       routeRepository?.unsubscribe(subscriber);
+      deactivateLayout?.();
     };
-  }, [flowEngine]);
+  }, [adminLayoutModel, adminLayoutModel?.layout?.uid, flowEngine]);
 
   useEffect(() => {
     if (typeof window === 'undefined') {
@@ -697,7 +717,10 @@ export const AdminLayoutComponent = observer((props: any) => {
                     <SetIsMobileLayout isMobile={isMobile} model={adminLayoutModel}>
                       <ConfigProvider theme={isMobile ? mobileTheme : theme}>
                         <GlobalStyle />
-                        <AdminLayoutContent onContentElementChange={handleLayoutContentElementChange} />
+                        <AdminLayoutContent
+                          layout={adminLayoutModel?.layout}
+                          onContentElementChange={handleLayoutContentElementChange}
+                        />
                       </ConfigProvider>
                     </SetIsMobileLayout>
                   );