@nocobase/flow-engine 2.0.0-alpha.45 → 2.0.0-alpha.46

package/lib/components/FlowModelRenderer.js

@@ -112,7 +112,9 @@ const FlowModelRendererCore = (0, import_reactive_react.observer)(
       }
       return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, rendered);
     }, "ContentOrError");
-    const contentKey = (model == null ? void 0 : model.use) || ((_a = model == null ? void 0 : model.constructor) == null ? void 0 : _a.name) || model.uid;
+    const rawUse = model == null ? void 0 : model.use;
+    const resolvedName = ((_a = model == null ? void 0 : model.constructor) == null ? void 0 : _a.name) || model.uid;
+    const contentKey = typeof rawUse === "string" ? `${rawUse}:${model.uid}` : `${resolvedName}:${model.uid}`;
     if (!showFlowSettings) {
       return wrapWithErrorBoundary(
         /* @__PURE__ */ import_react.default.createElement("div", { key: contentKey }, /* @__PURE__ */ import_react.default.createElement(ContentOrError, null))

package/lib/components/settings/wrappers/contextual/DefaultSettingsIcon.js

@@ -227,14 +227,27 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
   );
   const getModelConfigurableFlowsAndSteps = (0, import_react.useCallback)(
     async (targetModel, modelKey) => {
+      var _a;
       try {
-        const flows = targetModel.constructor.globalFlowRegistry.getFlows();
+        const flowsMap = new Map(targetModel.constructor.globalFlowRegistry.getFlows());
+        const originUse = targetModel == null ? void 0 : targetModel.use;
+        if (typeof originUse === "string" && originUse !== targetModel.constructor.name) {
+          const originCls = (_a = targetModel.flowEngine) == null ? void 0 : _a.getModelClass(originUse);
+          if (originCls == null ? void 0 : originCls.globalFlowRegistry) {
+            for (const [k, v] of originCls.globalFlowRegistry.getFlows()) {
+              if (!flowsMap.has(k)) {
+                flowsMap.set(k, v);
+              }
+            }
+          }
+        }
+        const flows = flowsMap;
         const flowsArray = Array.from(flows.values());
         const flowsWithSteps = await Promise.all(
           flowsArray.map(async (flow) => {
             const configurableSteps = await Promise.all(
               Object.entries(flow.steps).map(async ([stepKey, stepDefinition]) => {
-                var _a;
+                var _a2;
                 const actionStep = stepDefinition;
                 if (actionStep.hideInSettings) {
                   return null;
@@ -244,7 +257,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
                 let stepTitle = actionStep.title;
                 if (actionStep.use) {
                   try {
-                    const action = (_a = targetModel.getAction) == null ? void 0 : _a.call(targetModel, actionStep.use);
+                    const action = (_a2 = targetModel.getAction) == null ? void 0 : _a2.call(targetModel, actionStep.use);
                     hasActionUiSchema = action && action.uiSchema != null;
                     stepTitle = stepTitle || (action == null ? void 0 : action.title);
                   } catch (error) {

package/lib/flowEngine.d.ts

@@ -234,6 +234,11 @@ export declare class FlowEngine {
         delegateToParent?: boolean;
         delegate?: FlowContext;
     }): T;
+    /**
+     * 按类上的 resolveUse 链路解析最终用于实例化的模型类。
+     * 允许模型类根据上下文动态指定实际使用的类，支持多级 resolveUse。
+     */
+    private _resolveModelClass;
     /**
      * 尝试应用当前模型可用 flow 的 defaultParams（如果存在）到 model.stepParams。
      * 仅对尚未存在的步骤参数进行填充，不覆盖已有值。

package/lib/flowEngine.js

@@ -392,7 +392,10 @@ const _FlowEngine = class _FlowEngine {
    */
   createModel(options, extra) {
     const { parentId, uid, use: modelClassName, subModels } = options;
-    const ModelClass = typeof modelClassName === "string" ? this.getModelClass(modelClassName) : modelClassName;
+    const ModelClass = this._resolveModelClass(
+      typeof modelClassName === "string" ? this.getModelClass(modelClassName) : modelClassName,
+      options
+    );
     if (uid && this._modelInstances.has(uid)) {
       return this._modelInstances.get(uid);
     }
@@ -424,6 +427,41 @@ const _FlowEngine = class _FlowEngine {
     modelInstance._createSubModels(options.subModels);
     return modelInstance;
   }
+  /**
+   * 按类上的 resolveUse 链路解析最终用于实例化的模型类。
+   * 允许模型类根据上下文动态指定实际使用的类，支持多级 resolveUse。
+   */
+  _resolveModelClass(initial, options) {
+    let current = initial;
+    const visited = /* @__PURE__ */ new Set();
+    while (current) {
+      if (visited.has(current)) {
+        console.warn(`FlowEngine: resolveUse circular reference detected on '${current.name}'.`);
+        break;
+      }
+      visited.add(current);
+      const resolver = current == null ? void 0 : current.resolveUse;
+      if (typeof resolver !== "function") {
+        break;
+      }
+      const resolved = resolver(options, this);
+      if (!resolved || resolved === current) {
+        break;
+      }
+      let next;
+      if (typeof resolved === "string") {
+        next = this.getModelClass(resolved);
+        if (!next) {
+          console.warn(`FlowEngine: resolveUse returned '${resolved}' but no model is registered under that name.`);
+          return void 0;
+        }
+      } else {
+        next = resolved;
+      }
+      current = next;
+    }
+    return current;
+  }
   /**
    * 尝试应用当前模型可用 flow 的 defaultParams（如果存在）到 model.stepParams。
    * 仅对尚未存在的步骤参数进行填充，不覆盖已有值。
@@ -500,6 +538,7 @@ const _FlowEngine = class _FlowEngine {
       return false;
     }
     const modelInstance = this._modelInstances.get(uid);
+    modelInstance.invalidateFlowCache(void 0, true);
     modelInstance.clearForks();
     if ((_a = modelInstance.parent) == null ? void 0 : _a.subModels) {
       for (const subKey in modelInstance.parent.subModels) {

package/lib/flowSettings.js

@@ -691,6 +691,8 @@ const _FlowSettings = class _FlowSettings {
               }
             }
             currentView.close();
+            model.invalidateFlowCache("beforeRender", true);
+            await model.rerender();
             try {
               await (onSaved == null ? void 0 : onSaved());
             } catch (cbErr) {

package/lib/models/flowModel.d.ts

@@ -11,7 +11,7 @@ import { Emitter } from '../emitter';
 import { InstanceFlowRegistry } from '../flow-registry/InstanceFlowRegistry';
 import { FlowContext, FlowModelContext, FlowRuntimeContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
-import type { ActionDefinition, ArrayElementType, CreateModelOptions, CreateSubModelOptions, DefaultStructure, FlowDefinitionOptions, FlowModelMeta, FlowModelOptions, ModelConstructor, ParamObject, ParentFlowModel, PersistOptions, StepParams } from '../types';
+import type { ActionDefinition, ArrayElementType, CreateModelOptions, CreateSubModelOptions, DefaultStructure, FlowDefinitionOptions, FlowModelMeta, FlowModelOptions, ModelConstructor, ParamObject, ParentFlowModel, PersistOptions, RegisteredModelClassName, StepParams } from '../types';
 import { IModelComponentProps, ReadonlyModelProps } from '../types';
 import { ModelActionRegistry } from '../action-registry/ModelActionRegistry';
 import { ModelEventRegistry } from '../event-registry/ModelEventRegistry';
@@ -97,6 +97,11 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     static get globalFlowRegistry(): GlobalFlowRegistry;
     protected static get actionRegistry(): ModelActionRegistry;
     protected static get eventRegistry(): ModelEventRegistry;
+    /**
+     * 动态解析实际要实例化的模型类；可在子类中覆盖。
+     * 返回注册名或构造器，支持在 FlowEngine 中继续沿链解析。
+     */
+    static resolveUse?(options: CreateModelOptions, engine: FlowEngine): RegisteredModelClassName | ModelConstructor | void;
     /**
      * 注册仅当前 FlowModel 类及其子类可用的 Action。
      * 该注册是类级别的，不会影响全局（FlowEngine）的 Action 注册。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.45",
+  "version": "2.0.0-alpha.46",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.0.0-alpha.45",
-    "@nocobase/shared": "2.0.0-alpha.45",
+    "@nocobase/sdk": "2.0.0-alpha.46",
+    "@nocobase/shared": "2.0.0-alpha.46",
     "ahooks": "^3.7.2",
     "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
@@ -36,5 +36,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "ddb6d6b89f4f3dc49dc942d46901e9e6f159be58"
+  "gitHead": "ebf3cbeea4957a914e3157f3c6b570dba685c46f"
 }

package/src/components/FlowModelRenderer.tsx

@@ -222,8 +222,10 @@ const FlowModelRendererCore: React.FC<{
     };
 
     // 如果不显示流程设置，直接返回模型内容（可能包装 ErrorBoundary）
-    // 当模型类发生变化（如 replaceModel），强制重挂载内容，规避部分子组件 hooks deps 形态不一致导致的报错
-    const contentKey = (model as any)?.use || (model as any)?.constructor?.name || model.uid;
+    // 当模型类或 use 变化时重挂载内容，规避组件内部状态残留
+    const rawUse = (model as any)?.use;
+    const resolvedName = (model as any)?.constructor?.name || model.uid;
+    const contentKey = typeof rawUse === 'string' ? `${rawUse}:${model.uid}` : `${resolvedName}:${model.uid}`;
 
     if (!showFlowSettings) {
       return wrapWithErrorBoundary(

package/src/components/settings/wrappers/contextual/DefaultSettingsIcon.tsx

@@ -267,8 +267,23 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
   const getModelConfigurableFlowsAndSteps = useCallback(
     async (targetModel: FlowModel, modelKey?: string): Promise<FlowInfo[]> => {
       try {
-        // 仅使用静态流（类级全局注册的 flows），排除实例动态流
-        const flows = (targetModel.constructor as typeof FlowModel).globalFlowRegistry.getFlows();
+        // 仅使用静态流（类级全局注册的 flows）
+        const flowsMap = new Map((targetModel.constructor as typeof FlowModel).globalFlowRegistry.getFlows());
+
+        // 如果有原始 use 且与当前类不同，合并原始模型类的静态 flows（用于入口模型 resolveUse 场景）
+        const originUse = targetModel?.use;
+        if (typeof originUse === 'string' && originUse !== targetModel.constructor.name) {
+          const originCls = targetModel.flowEngine?.getModelClass(originUse) as typeof FlowModel | undefined;
+          if (originCls?.globalFlowRegistry) {
+            for (const [k, v] of originCls.globalFlowRegistry.getFlows()) {
+              if (!flowsMap.has(k)) {
+                flowsMap.set(k, v);
+              }
+            }
+          }
+        }
+
+        const flows = flowsMap;
 
         const flowsArray = Array.from(flows.values());
 

package/src/components/settings/wrappers/contextual/__tests__/DefaultSettingsIcon.test.tsx

@@ -422,4 +422,59 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
     menu.onClick?.({ key: 'copy-pop-uid:items[0]:popupSettings:stage' });
     expect((navigator as any).clipboard.writeText).toHaveBeenCalledWith('child-2');
   });
+
+  it('merges static flows from origin use when instance class differs', async () => {
+    class TargetModel extends FlowModel {
+      static setupFlows() {
+        this.registerFlow({
+          key: 'targetFlow',
+          title: 'Target Flow',
+          steps: {
+            targetStep: { title: 'Target Step', uiSchema: { x: { type: 'string', 'x-component': 'Input' } } },
+          },
+        });
+      }
+    }
+    class EntryModel extends FlowModel {
+      static resolveUse() {
+        return TargetModel;
+      }
+      static setupFlows() {
+        this.registerFlow({
+          key: 'originFlow',
+          title: 'Origin Flow',
+          steps: {
+            originStep: { title: 'Origin Step', uiSchema: { y: { type: 'string', 'x-component': 'Input' } } },
+          },
+        });
+      }
+    }
+
+    TargetModel.setupFlows();
+    EntryModel.setupFlows();
+
+    const engine = new FlowEngine();
+    engine.registerModels({ EntryModel, TargetModel });
+
+    const model = engine.createModel({ use: 'EntryModel', uid: 'merge-origin', flowEngine: engine });
+
+    render(
+      React.createElement(
+        ConfigProvider as any,
+        null,
+        React.createElement(App as any, null, React.createElement(DefaultSettingsIcon as any, { model })),
+      ),
+    );
+
+    await waitFor(() => {
+      const menu = (globalThis as any).__lastDropdownMenu;
+      expect(menu).toBeTruthy();
+      const items = (menu?.items || []) as any[];
+      const groups = items.filter((it) => it.type === 'group').map((it) => String(it.label));
+      expect(groups).toContain('Origin Flow');
+      expect(groups).toContain('Target Flow');
+      expect(items.some((it) => String(it.key || '').startsWith('originFlow:originStep'))).toBe(true);
+      expect(items.some((it) => String(it.key || '').startsWith('targetFlow:targetStep'))).toBe(true);
+    });
+  });
 });

package/src/flowEngine.ts

@@ -30,6 +30,7 @@ import type {
   ModelConstructor,
   PersistOptions,
   ResourceType,
+  RegisteredModelClassName,
 } from './types';
 import { isInheritedFrom } from './utils';
 
@@ -458,7 +459,10 @@ export class FlowEngine {
     extra?: { delegateToParent?: boolean; delegate?: FlowContext },
   ): T {
     const { parentId, uid, use: modelClassName, subModels } = options;
-    const ModelClass = typeof modelClassName === 'string' ? this.getModelClass(modelClassName) : modelClassName;
+    const ModelClass = this._resolveModelClass(
+      typeof modelClassName === 'string' ? this.getModelClass(modelClassName) : modelClassName,
+      options,
+    );
 
     if (uid && this._modelInstances.has(uid)) {
       return this._modelInstances.get(uid) as T;
@@ -505,6 +509,53 @@ export class FlowEngine {
     return modelInstance as T;
   }
 
+  /**
+   * 按类上的 resolveUse 链路解析最终用于实例化的模型类。
+   * 允许模型类根据上下文动态指定实际使用的类，支持多级 resolveUse。
+   */
+  private _resolveModelClass(
+    initial: ModelConstructor | undefined,
+    options: CreateModelOptions,
+  ): ModelConstructor | undefined {
+    let current = initial;
+    const visited = new Set<ModelConstructor>();
+
+    while (current) {
+      if (visited.has(current)) {
+        console.warn(`FlowEngine: resolveUse circular reference detected on '${current.name}'.`);
+        break;
+      }
+      visited.add(current);
+
+      const resolver = (current as any)?.resolveUse as
+        | ((opts: CreateModelOptions, engine: FlowEngine) => RegisteredModelClassName | ModelConstructor | void)
+        | undefined;
+      if (typeof resolver !== 'function') {
+        break;
+      }
+
+      const resolved = resolver(options, this);
+      if (!resolved || resolved === current) {
+        break;
+      }
+
+      let next: ModelConstructor | undefined;
+      if (typeof resolved === 'string') {
+        next = this.getModelClass(resolved);
+        if (!next) {
+          console.warn(`FlowEngine: resolveUse returned '${resolved}' but no model is registered under that name.`);
+          return undefined;
+        }
+      } else {
+        next = resolved;
+      }
+
+      current = next;
+    }
+
+    return current;
+  }
+
   /**
    * 尝试应用当前模型可用 flow 的 defaultParams（如果存在）到 model.stepParams。
    * 仅对尚未存在的步骤参数进行填充，不覆盖已有值。
@@ -591,6 +642,8 @@ export class FlowEngine {
       return false;
     }
     const modelInstance = this._modelInstances.get(uid) as FlowModel;
+    // Ensure any cached beforeRender results tied to this uid are cleared before removal.
+    modelInstance.invalidateFlowCache(undefined, true);
     modelInstance.clearForks();
     // 从父模型中移除当前模型的引用
     if (modelInstance.parent?.subModels) {

package/src/flowSettings.ts

@@ -875,6 +875,10 @@ export class FlowSettings {
 
             currentView.close();
 
+            // 配置变更后立即刷新 beforeRender，避免命中旧缓存导致界面不更新
+            model.invalidateFlowCache('beforeRender', true);
+            await model.rerender();
+
             // 触发保存成功回调
             try {
               await onSaved?.();

package/src/models/__tests__/flowEngine.resolveUse.test.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { describe, expect, test, vi, beforeEach, afterEach } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { ErrorFlowModel, FlowModel } from '../flowModel';
+
+describe('FlowEngine.createModel resolveUse hook', () => {
+  let engine: FlowEngine;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  test('should use resolveUse returning registered name', () => {
+    class DynamicTarget extends FlowModel {}
+    class DynamicEntry extends FlowModel {
+      static resolveUse() {
+        return 'DynamicTarget';
+      }
+    }
+
+    engine.registerModels({ DynamicEntry, DynamicTarget });
+
+    const model = engine.createModel({ use: 'DynamicEntry', uid: 'dynamic-entry', flowEngine: engine });
+
+    expect(model).toBeInstanceOf(DynamicTarget);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test('should chain resolveUse until final constructor', () => {
+    class ChainLeaf extends FlowModel {}
+    class ChainMid extends FlowModel {
+      static resolveUse() {
+        return ChainLeaf;
+      }
+    }
+    class ChainStart extends FlowModel {
+      static resolveUse() {
+        return 'ChainMid';
+      }
+    }
+
+    engine.registerModels({ ChainLeaf, ChainMid, ChainStart });
+
+    const model = engine.createModel({ use: 'ChainStart', uid: 'chain-start', flowEngine: engine });
+
+    expect(model).toBeInstanceOf(ChainLeaf);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  test('should break resolveUse on circular reference and warn', () => {
+    class LoopModel extends FlowModel {
+      static resolveUse() {
+        return 'LoopModel';
+      }
+    }
+
+    engine.registerModels({ LoopModel });
+
+    const model = engine.createModel({ use: 'LoopModel', uid: 'loop-model', flowEngine: engine });
+
+    expect(model).toBeInstanceOf(LoopModel);
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  test('should fall back to ErrorFlowModel when resolveUse returns unregistered name', () => {
+    class MissingTargetEntry extends FlowModel {
+      static resolveUse() {
+        return 'NoSuchModel';
+      }
+    }
+
+    engine.registerModels({ MissingTargetEntry });
+
+    const model = engine.createModel({ use: 'MissingTargetEntry', uid: 'missing-target', flowEngine: engine });
+
+    expect(model).toBeInstanceOf(ErrorFlowModel);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("resolveUse returned 'NoSuchModel' but no model is registered under that name."),
+    );
+  });
+
+  test('should keep original use in serialized data after resolveUse', () => {
+    class DynamicTarget extends FlowModel {}
+    class DynamicEntry extends FlowModel {
+      static resolveUse() {
+        return DynamicTarget;
+      }
+    }
+
+    engine.registerModels({ DynamicEntry, DynamicTarget });
+
+    const model = engine.createModel({ use: 'DynamicEntry', uid: 'dynamic-entry', flowEngine: engine });
+    const serialized = model.serialize();
+
+    expect(model).toBeInstanceOf(DynamicTarget);
+    expect(serialized.use).toBe('DynamicEntry');
+  });
+});

package/src/models/flowModel.tsx

@@ -31,6 +31,7 @@ import type {
   ParamObject,
   ParentFlowModel,
   PersistOptions,
+  RegisteredModelClassName,
   StepDefinition,
   StepParams,
 } from '../types';
@@ -318,6 +319,15 @@ export class FlowModel<Structure extends DefaultStructure = DefaultStructure> {
     return registry;
   }
 
+  /**
+   * 动态解析实际要实例化的模型类；可在子类中覆盖。
+   * 返回注册名或构造器，支持在 FlowEngine 中继续沿链解析。
+   */
+  static resolveUse?(
+    options: CreateModelOptions,
+    engine: FlowEngine,
+  ): RegisteredModelClassName | ModelConstructor | void;
+
   /**
    * 注册仅当前 FlowModel 类及其子类可用的 Action。
    * 该注册是类级别的，不会影响全局（FlowEngine）的 Action 注册。