@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/__tests__/viewScopedFlowEngine.test.ts

@@ -59,7 +59,19 @@ describe('ViewScopedFlowEngine', () => {
     expect(child.getModel(uid)).toBe(cm);
   });
 
-  it('isolates auto flow cache across engines with identical model uid', async () => {
+  it('mounts parent model from previous engine when creating models in scoped engine', () => {
+    const parent = new FlowEngine();
+    const scoped = createViewScopedEngine(parent);
+
+    const parentModel = parent.createModel({ use: 'FlowModel', uid: 'parent-uid' });
+
+    const childModel = scoped.createModel({ use: 'FlowModel', uid: 'child-uid', parentId: parentModel.uid });
+
+    expect(childModel.parent).toBe(parentModel);
+    expect(childModel.parent?.uid).toBe('parent-uid');
+  });
+
+  it('isolates beforeRender event cache across engines with identical model uid', async () => {
     const parent = new FlowEngine();
     const child = createViewScopedEngine(parent);
 
@@ -81,11 +93,11 @@ describe('ViewScopedFlowEngine', () => {
     const pm = parent.createModel<CounterModel>({ use: CounterModel, uid });
     const cm = child.createModel<CounterModel>({ use: CounterModel, uid });
 
-    await pm.applyAutoFlows();
+    await pm.dispatchEvent('beforeRender');
     expect(count).toBe(1);
 
     // If cache was shared, the next call would hit cache and not increment.
-    await cm.applyAutoFlows();
+    await cm.dispatchEvent('beforeRender');
     expect(count).toBe(2);
   });
 
@@ -209,4 +221,90 @@ describe('ViewScopedFlowEngine', () => {
     const resolved = root.getModel<TM>(uid, true);
     expect(resolved?.flowEngine.previousEngine).toBe(root);
   });
+
+  it('hydrateModelFromPreviousEngines returns null for ALL subModels when parent has flowSettingsEnabled (bug fix: ensures all children rebuild)', async () => {
+    // Bug scenario: When a parent model (like a popup) has flowSettingsEnabled=true,
+    // ALL its child models should be rebuilt from scratch, not just those with their own flowSettingsEnabled.
+    // Previously, only child models with their own flowSettingsEnabled were being rebuilt.
+    const root = new FlowEngine();
+
+    // Mock minimal api to satisfy ctx.auth and related getters
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    root.context.defineProperty('api', { value: api });
+
+    // Create parent model with subModels in root engine
+    class ParentModel extends FlowModel {}
+    class ChildModel extends FlowModel {}
+    root.registerModels({ ParentModel, ChildModel });
+
+    const parentModel = root.createModel<ParentModel>({ use: ParentModel, uid: 'parent-with-settings' });
+    const child1 = root.createModel<ChildModel>({ use: ChildModel, uid: 'child-1' });
+    const child2 = root.createModel<ChildModel>({ use: ChildModel, uid: 'child-2' });
+
+    // Mount children under parent (neither child has flowSettingsEnabled)
+    parentModel.setSubModel('popup', child1);
+    parentModel.addSubModel('items', child2);
+
+    // Enable flowSettingsEnabled on parent (simulating a popup/drawer that needs fresh data)
+    parentModel.context.flowSettingsEnabled = true;
+
+    // Create scoped engine
+    const scoped = createViewScopedEngine(root);
+
+    // Both children should return null from hydration because parent has flowSettingsEnabled
+    // This is the bug fix: previously only children with their own flowSettingsEnabled would return null
+    const result1 = (scoped as any).hydrateModelFromPreviousEngines({
+      parentId: 'parent-with-settings',
+      subKey: 'popup',
+    });
+    const result2 = (scoped as any).hydrateModelFromPreviousEngines({
+      parentId: 'parent-with-settings',
+      subKey: 'items',
+    });
+
+    // Both should be null, ensuring all children are rebuilt with fresh data
+    expect(result1).toBeNull();
+    expect(result2).toBeNull();
+  });
+
+  it('hydrateModelFromPreviousEngines returns hydrated model when parent does NOT have flowSettingsEnabled', async () => {
+    const root = new FlowEngine();
+
+    // Mock minimal api to satisfy ctx.auth and related getters
+    const api = new SDKApiClient({ storageType: 'memory' });
+    api.auth.role = 'guest';
+    api.auth.locale = 'en-US';
+    api.auth.token = 't';
+    root.context.defineProperty('api', { value: api });
+
+    // Create parent model with subModels in root engine
+    class ParentModel extends FlowModel {}
+    class ChildModel extends FlowModel {}
+    root.registerModels({ ParentModel, ChildModel });
+
+    const parentModel = root.createModel<ParentModel>({ use: ParentModel, uid: 'parent-normal' });
+    const child = root.createModel<ChildModel>({ use: ChildModel, uid: 'child-normal' });
+
+    // Mount child under parent
+    parentModel.setSubModel('content', child);
+
+    // Parent does NOT have flowSettingsEnabled (default behavior)
+    expect(parentModel.context.flowSettingsEnabled).toBeFalsy();
+
+    // Create scoped engine
+    const scoped = createViewScopedEngine(root);
+
+    // Call the private method hydrateModelFromPreviousEngines directly
+    const result = (scoped as any).hydrateModelFromPreviousEngines({
+      parentId: 'parent-normal',
+      subKey: 'content',
+    });
+
+    // hydrateModelFromPreviousEngines should return a hydrated model (not null)
+    expect(result).not.toBeNull();
+    expect(result?.uid).toBe('child-normal');
+  });
 });

package/src/acl/Acl.tsx

@@ -6,78 +6,133 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-
-import { FlowModel } from '../models/flowModel';
+import _, { omit } from 'lodash';
 import { FlowEngine } from '../flowEngine';
+import { FlowModel } from '../models/flowModel';
 
 interface CheckOptions {
   dataSourceKey: string;
   resourceName: string;
   actionName: string;
   fields?: string[];
+  recordPkValue?: string | number;
+  allowedActions: any[];
 }
 
 export class ACL {
-  private dataSources: Record<string, any> = {};
+  private data: Record<string, any> = {};
+  private meta: Record<string, any> = {};
   private loaded = false;
   private loadingPromise: Promise<void> | null = null;
+  // 用于识别当前鉴权状态（例如切换登录用户后应重新加载）
+  // 记录上一次用于鉴权的 token，用于识别登录态变更
+  private lastToken: string | null = null;
 
   constructor(private flowEngine: FlowEngine) {}
 
+  setData(data: Record<string, any>) {
+    this.data = _.cloneDeep(data);
+  }
+
+  setMeta(data: Record<string, any>) {
+    this.meta = _.cloneDeep(data);
+  }
+
   async load() {
-    if (this.loaded) return;
-
-    if (!this.loadingPromise) {
-      this.loadingPromise = (async () => {
-        const { data } = await this.flowEngine.context.api.request({
-          url: 'roles:check',
-        });
-        this.dataSources = data || {};
-        this.loaded = true;
-      })();
+    // 基于 token 识别登录态是否发生变化
+    const currentToken = this.flowEngine?.context?.api?.auth?.token || '';
+
+    // 已加载但登录态变更：强制重载
+    if (this.loaded && this.lastToken !== currentToken) {
+      this.loaded = false;
+      this.loadingPromise = null;
+      this.data = {};
+      this.meta = {};
     }
 
+    const { data } = await this.flowEngine.context.api.request({
+      url: 'roles:check',
+    });
+    this.data = data?.data || {};
+    this.meta = data?.meta || {};
+    this.loaded = true;
+    this.lastToken = currentToken;
+
     await this.loadingPromise;
   }
 
   getActionAlias(actionName: string) {
-    return this.dataSources.data?.actionAlias?.[actionName] || actionName;
+    return this.data.actionAlias?.[actionName] || actionName;
   }
 
-  inResources(resourceName: string) {
-    return this.dataSources.data?.resources?.includes?.(resourceName);
+  inResources(resourceName: string, dataSourceName) {
+    const { dataSources: dataSourcesAcl } = this?.meta || {};
+    const data = { ...this.data, ...omit(dataSourcesAcl?.[dataSourceName], 'snippets') };
+    return data.resources?.includes?.(resourceName);
   }
-  getResourceActionParams(resourceName, actionName) {
+  getResourceActionParams(resourceName, actionName, dataSourceName) {
     const actionAlias = this.getActionAlias(actionName);
-    return (
-      this.dataSources.data?.actions?.[`${resourceName}:${actionAlias}`] || this.dataSources.data?.actions?.[actionName]
-    );
+    const { dataSources: dataSourcesAcl } = this?.meta || {};
+    const data = { ...this.data, ...omit(dataSourcesAcl?.[dataSourceName], 'snippets') };
+    return data.actions?.[`${resourceName}:${actionAlias}`] || data.actions?.[actionName];
   }
 
-  getStrategyActionParams(actionName: string) {
+  getStrategyActionParams(actionName: string, dataSourceName) {
     const actionAlias = this.getActionAlias(actionName);
-    const strategyAction = this.dataSources.data?.strategy?.actions?.find((action) => {
+    const { dataSources: dataSourcesAcl } = this?.meta || {};
+    const data = { ...this.data, ...omit(dataSourcesAcl?.[dataSourceName], 'snippets') };
+    const strategyAction = data?.strategy?.actions?.find((action) => {
       const [value] = action.split(':');
       return value === actionAlias;
     });
     return strategyAction ? {} : null;
   }
 
+  getIgnoreScope = (options: any = {}) => {
+    const { recordPkValue, allowedActions, actionName } = options;
+    let ignoreScope = false;
+    if (options.ignoreScope) {
+      ignoreScope = true;
+    }
+    if (actionName === 'create') {
+      ignoreScope = true;
+    }
+    if (!recordPkValue || !allowedActions) {
+      ignoreScope = true;
+    }
+    return ignoreScope;
+  };
+  verifyScope = (actionName: string, recordPkValue: any, allowedActions) => {
+    const actionAlias = this.getActionAlias(actionName);
+    const scopeValues = allowedActions?.[actionAlias];
+
+    if (!Array.isArray(scopeValues)) {
+      return null;
+    }
+
+    return scopeValues.map((v) => String(v)).includes(String(recordPkValue));
+  };
   parseAction(options: CheckOptions) {
-    const { resourceName, actionName, dataSourceKey = 'main' } = options;
+    const { resourceName, actionName, dataSourceKey = 'main', recordPkValue, allowedActions } = options;
     const targetResource =
       resourceName?.includes('.') &&
       this.flowEngine.context.dataSourceManager
         .getDataSource(dataSourceKey)
         .collectionManager.getAssociation(resourceName)?.target;
+    if (!this.getIgnoreScope(options)) {
+      const r = this.verifyScope(actionName, recordPkValue, allowedActions);
+      if (!r) {
+        return null;
+      }
+    }
 
-    if (this.inResources(targetResource)) {
-      return this.getResourceActionParams(targetResource, actionName);
+    if (this.inResources(targetResource, dataSourceKey)) {
+      return this.getResourceActionParams(targetResource, actionName, dataSourceKey);
     }
-    if (this.inResources(resourceName)) {
-      return this.getResourceActionParams(resourceName, actionName);
+    if (this.inResources(resourceName, dataSourceKey)) {
+      return this.getResourceActionParams(resourceName, actionName, dataSourceKey);
     }
-    return this.getStrategyActionParams(actionName);
+    return this.getStrategyActionParams(actionName, dataSourceKey);
   }
 
   parseField(options: CheckOptions) {
@@ -95,9 +150,8 @@ export class ACL {
   }
 
   async aclCheck(options: CheckOptions): Promise<boolean> {
-    await this.load();
-    const { data } = this.dataSources;
-    const { allowAll } = data;
+    // await this.load();
+    const { allowAll } = this.data;
     if (allowAll) {
       return true;
     }

package/src/acl/__tests__/Acl.test.tsx

@@ -35,7 +35,7 @@ describe('ACL', () => {
     };
     const engine = makeEngine(payload);
     const acl = new ACL(engine);
-    await acl.load();
+    acl.setData(payload.data);
     expect(acl.getActionAlias('remove')).toBe('destroy');
     expect(acl.inResources('posts')).toBe(true);
     expect(acl.getResourceActionParams('posts', 'remove')).toEqual({ whitelist: ['title'] });
@@ -54,6 +54,7 @@ describe('ACL', () => {
     };
     const engine = makeEngine(payload);
     const acl = new ACL(engine);
+    acl.setData(payload.data);
     const ok = await acl.aclCheck({
       dataSourceKey: 'main',
       resourceName: 'posts',
@@ -69,4 +70,45 @@ describe('ACL', () => {
     });
     expect(notOk).toBe(false);
   });
+
+  it('reloads permissions when auth token changes', async () => {
+    const payload1 = {
+      data: {
+        allowAll: false,
+        actionAlias: { remove: 'destroy' },
+        resources: ['posts'],
+        actions: {},
+        strategy: { actions: [] },
+      },
+    };
+    const payload2 = {
+      data: {
+        allowAll: false,
+        actionAlias: { remove: 'erase' },
+        resources: ['posts'],
+        actions: {},
+        strategy: { actions: [] },
+      },
+    };
+
+    const engine = new FlowEngine();
+    const api: any = {
+      auth: { token: 't1' },
+      request: vi.fn().mockImplementation(async () => {
+        // 返回依据当前 token 的不同 ACL 数据
+        return api.auth.token === 't1' ? { data: payload1 } : { data: payload2 };
+      }),
+    };
+    engine.context.defineProperty('api', { value: api });
+
+    const acl = new ACL(engine);
+    acl.setData(payload1.data);
+    expect(acl.getActionAlias('remove')).toBe('destroy');
+
+    // 切换 token，应触发下次校验时的 ACL 重载
+    api.auth.token = 't2';
+    acl.setData(payload2.data);
+    await acl.aclCheck({ dataSourceKey: 'main', resourceName: 'posts', actionName: 'remove' });
+    expect(acl.getActionAlias('remove')).toBe('erase');
+  });
 });

package/src/components/DynamicFlowsEditor.tsx

@@ -7,17 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DeleteOutlined, PlusOutlined } from '@ant-design/icons';
-import { uid } from '@nocobase/utils/client';
-import { Collapse, Space, Button, Tabs, Input, Modal, Form, Empty, Select } from 'antd';
-import type { FormInstance } from 'antd';
-import { observer } from '@formily/react';
 import React from 'react';
-import { FlowModel } from '../models';
-import { FlowDefinition } from '../FlowDefinition';
-import { FlowDefinitionOptions } from '../types';
-
-const Panel = Collapse.Panel;
 
 /**
  * 动态流编辑器（纯组件）

package/src/components/FieldModelRenderer.tsx

@@ -20,7 +20,6 @@ const flowModelRendererPropKeys: (keyof FlowModelRendererProps)[] = [
   'flowSettingsVariant',
   'hideRemoveInSettings',
   'showTitle',
-  'skipApplyAutoFlows',
   'inputArgs',
   'showErrorFallback',
   'settingsMenuLevel',
@@ -32,30 +31,44 @@ export function FieldModelRenderer(props: any) {
   const composingRef = useRef(false);
 
   const handleChange = (e: any) => {
-    const val = e?.target?.value || e;
+    let val;
+    if (e && e.target && typeof e.target.value !== 'undefined') {
+      val = e.target.value;
+    } else if (
+      typeof e === 'string' ||
+      typeof e === 'number' ||
+      typeof e === 'boolean' ||
+      (typeof e === 'object' && !(e instanceof Event))
+    ) {
+      val = e;
+    } else {
+      val = null;
+    }
+
     model.setProps({ value: val });
     if (!composingRef.current) {
-      props.onChange(e);
+      props.onChange?.(val);
     }
   };
-
   const handleCompositionStart = () => {
     composingRef.current = true;
   };
 
-  const handleCompositionEnd = (e: React.CompositionEvent<HTMLInputElement>) => {
+  const handleCompositionEnd = (e: React.CompositionEvent<HTMLInputElement>, flag = true) => {
     composingRef.current = false;
-    props.onChange(e);
+    if (flag) {
+      props.onChange(e);
+    }
   };
 
   const modelProps = {
-    ..._.omit(rest, flowModelRendererPropKeys),
-    onChange: handleChange,
     onCompositionStart: handleCompositionStart,
     onCompositionEnd: handleCompositionEnd,
+    ..._.omit(rest, flowModelRendererPropKeys),
+    onChange: handleChange,
   };
   useEffect(() => {
-    model.setProps(modelProps);
+    model && model.setProps(modelProps);
   }, [modelProps]);
 
   return <FlowModelRenderer model={model} {...rest} />;

package/src/components/FieldSkeleton.tsx

@@ -0,0 +1,27 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import React from 'react';
+import { useFlowEngine } from '../provider';
+
+export const FieldSkeleton: React.FC = () => {
+  const flowEngine = useFlowEngine();
+  const token = flowEngine.context.themeToken;
+  return (
+    <span
+      style={{
+        display: 'inline-block',
+        width: '100%',
+        height: 16,
+        backgroundColor: token.colorFillSecondary,
+        borderRadius: token.borderRadiusSM,
+      }}
+    />
+  );
+};

package/src/components/FlowContextSelector.tsx

@@ -10,6 +10,7 @@
 import React, { useCallback, useRef, useMemo, useState, useEffect } from 'react';
 import { Button, Cascader, Tooltip } from 'antd';
 import { QuestionCircleOutlined } from '@ant-design/icons';
+import { cx, css } from '@emotion/css';
 import type { ContextSelectorItem, FlowContextSelectorProps } from './variables/types';
 import {
   buildContextSelectorItems,
@@ -25,6 +26,14 @@ const defaultButtonStyle = {
   fontFamily: 'New York, Times New Roman, Times, serif',
 };
 
+// 参考 1.x FilterItem 的实现：下拉高度随内容自适应，过长时占用更多可视区以减少滚动。
+const cascaderPopupAutoHeightClassName = css`
+  .ant-cascader-menu {
+    height: fit-content;
+    max-height: 50vh;
+  }
+`;
+
 const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
   value,
   onChange,
@@ -35,6 +44,7 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
   formatPathToValue: customFormatPathToValue,
   open,
   onlyLeafSelectable = false,
+  ignoreFieldNames,
   ...cascaderProps
 }) => {
   // 记录最后点击的路径，用于双击检测
@@ -97,8 +107,11 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
   const options = useMemo(() => {
     if (!resolvedMetaTree) return [];
     const base = buildContextSelectorItems(resolvedMetaTree);
-    return translateOptions(base);
-  }, [resolvedMetaTree, updateFlag, translateOptions]);
+    return translateOptions(base).filter((item) => {
+      if (!ignoreFieldNames || ignoreFieldNames.length === 0) return true;
+      return !ignoreFieldNames.includes(item.meta?.name || '');
+    });
+  }, [resolvedMetaTree, updateFlag, translateOptions, ignoreFieldNames]);
 
   // 内部展开路径：在 onlyLeafSelectable=true 时，点击父节点不会触发 onChange，
   // 但会触发 loadData。我们在此记录路径以在懒加载后保持展开。
@@ -234,6 +247,10 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
     [onChange, customFormatPathToValue, onlyLeafSelectable],
   );
 
+  const mergedPopupClassName = useMemo(() => {
+    return cx(cascaderPopupAutoHeightClassName, cascaderProps.popupClassName);
+  }, [cascaderProps.popupClassName]);
+
   return (
     <Cascader
       {...cascaderProps}
@@ -246,6 +263,7 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
       expandTrigger="click"
       open={open}
       showSearch={children === null}
+      popupClassName={mergedPopupClassName}
     >
       {children === null ? null : children || defaultChildren}
     </Cascader>