@nocobase/flow-engine 2.0.0-beta.9 → 2.0.1

package/src/data-source/index.ts

@@ -99,7 +99,7 @@ export class DataSource {
   }
 
   get displayName() {
-    return this.options.displayName ? this.flowEngine.translate(this.options.displayName) : this.key;
+    return this.flowEngine.translate(this.options.displayName, { ns: 'lm-collections' }) || this.key;
   }
 
   get key() {
@@ -187,6 +187,9 @@ export interface CollectionOptions {
 export class CollectionManager {
   collections: Map<string, Collection>;
 
+  allCollectionsInheritChain: string[];
+  protected childrenCollectionsName: { supportView?: string[]; notSupportView?: string[] } = {};
+
   constructor(public dataSource: DataSource) {
     this.collections = observable.shallow<Map<string, Collection>>(new Map());
   }
@@ -339,117 +342,80 @@ export class CollectionManager {
     };
     return getChildrens(name);
   }
-
-  getCollectionFieldsOptions(
-    collectionName: string,
-    type?: string | string[],
-    interfaces?: string | string[],
-    opts?: {
-      dataSource?: string;
-      cached?: Record<string, any>;
-      collectionNames?: string[];
-      /**
-       * 为 true 时允许查询所有关联字段
-       * 为 Array<string> 时仅允许查询指定的关联字段
-       */
-      association?: boolean | string[];
-      /**
-       * Max depth of recursion
-       */
-      maxDepth?: number;
-      allowAllTypes?: boolean;
-      /**
-       * 排除这些接口的字段
-       */
-      exceptInterfaces?: string[];
-      /**
-       * field value 的前缀，用 . 连接，比如 a.b.c
-       */
-      prefixFieldValue?: string;
-      /**
-       * 是否使用 prefixFieldValue 作为 field value
-       */
-      usePrefix?: boolean;
-    },
-  ) {
-    const {
-      association = false,
-      cached = {},
-      collectionNames = [collectionName],
-      maxDepth = 1,
-      allowAllTypes = false,
-      exceptInterfaces = [],
-      prefixFieldValue = '',
-      usePrefix = false,
-      dataSource: customDataSourceNameValue,
-    } = opts || {};
-
-    if (collectionNames.length - 1 > maxDepth) {
-      return;
+  getChildrenCollectionsName(name, isSupportView = false) {
+    const cacheKey = isSupportView ? 'supportView' : 'notSupportView';
+    if (this.childrenCollectionsName[cacheKey]) {
+      return this.childrenCollectionsName[cacheKey].slice();
     }
 
-    if (cached[collectionName]) {
-      // avoid infinite recursion
-      return _.cloneDeep(cached[collectionName]);
-    }
-
-    // Fetch the collection
-    const collection = this.getCollection(collectionName);
-    if (!collection) {
-      throw new Error(`Collection ${collectionName} not found`);
-    }
-
-    // Get the fields of the collection
-    const fields = collection.getFields(); // Assuming `getFields` returns an array of fields for the collection.
-
-    const options = fields
-      ?.filter(
-        (field) =>
-          field.interface &&
-          !exceptInterfaces.includes(field.interface) &&
-          (allowAllTypes ||
-            (type && type.includes(field.type)) ||
-            (interfaces && interfaces.includes(field.interface)) ||
-            (association && field.target && field.target !== collectionName && Array.isArray(association)
-              ? association.includes(field.interface)
-              : false)),
-      )
-      ?.map((field) => {
-        const result: CascaderProps<any>['options'][0] = {
-          value: usePrefix && prefixFieldValue ? `${prefixFieldValue}.${field.name}` : field.name,
-          label: field?.uiSchema?.title || field.name,
-          ...field,
-        };
+    const children: string[] = [];
+    const collections = [...this.getCollections()];
+    const getChildrenCollectionsInner = (collectionName: string) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return [...v.inherits]?.includes(collectionName);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        children.push(collectionKey);
+        return getChildrenCollectionsInner(collectionKey);
+      });
+      if (isSupportView) {
+        const sourceCollections = collections.filter((v: any) => {
+          return [...v.sources]?.length === 1 && v?.sources[0] === collectionName;
+        });
+        sourceCollections.forEach((v) => {
+          const collectionKey = v.name;
+          children.push(v.name);
+          return getChildrenCollectionsInner(collectionKey);
+        });
+      }
+      return _.uniq(children);
+    };
 
-        if (association && field.target) {
-          result.children = collectionNames.includes(field.target)
-            ? []
-            : this.getCollectionFieldsOptions(field.target, type, interfaces, {
-                ...opts,
-                cached,
-                dataSource: customDataSourceNameValue,
-                collectionNames: [...collectionNames, field.target],
-                prefixFieldValue: usePrefix
-                  ? prefixFieldValue
-                    ? `${prefixFieldValue}.${field.name}`
-                    : field.name
-                  : '',
-                usePrefix,
-              });
-
-          // If no children are found, don't return the field
-          if (!result.children?.length) {
-            return null;
+    this.childrenCollectionsName[cacheKey] = getChildrenCollectionsInner(name);
+    return this.childrenCollectionsName[cacheKey];
+  }
+
+  getAllCollectionsInheritChain(name) {
+    if (this.allCollectionsInheritChain) {
+      return this.allCollectionsInheritChain.slice();
+    }
+
+    const collectionsInheritChain = [name];
+    const getInheritChain = (name: string) => {
+      const collection = this.getCollection(name);
+      if (collection) {
+        const { inherits } = collection as any;
+        const children = this.getChildrenCollectionsName(name);
+        // 搜寻祖先表
+        if (inherits) {
+          for (let index = 0; index < inherits.length; index++) {
+            const collectionKey = inherits[index];
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
+        }
+        // 搜寻后代表
+        if (children) {
+          for (let index = 0; index < children.length; index++) {
+            const collection = this.getCollection(children[index]);
+            const collectionKey = collection.name;
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
           }
         }
-        return result;
-      })
-      // Filter out null values (i.e., fields with no valid options)
-      .filter(Boolean);
+      }
+      return collectionsInheritChain;
+    };
 
-    // Cache the result to avoid infinite recursion
-    cached[collectionName] = options;
-    return options;
+    this.allCollectionsInheritChain = getInheritChain(name);
+    return this.allCollectionsInheritChain || [];
   }
 }
 
@@ -486,6 +452,9 @@ export class Collection {
     if (typeof this.filterTargetKey === 'string') {
       return record[this.filterTargetKey];
     }
+    if (Array.isArray(this.filterTargetKey) && this.filterTargetKey.length === 1) {
+      return record[this.filterTargetKey[0]];
+    }
     return _.pick(record, this.filterTargetKey);
   }
 
@@ -527,7 +496,7 @@ export class Collection {
     return this.options.storage || 'local';
   }
   get title() {
-    return this.options.title ? this.flowEngine.translate(this.options.title) : this.name;
+    return this.flowEngine.translate(this.options.title, { ns: 'lm-collections' }) || this.name;
   }
 
   get titleCollectionField() {
@@ -800,8 +769,8 @@ export class CollectionField {
   }
 
   get title() {
-    const titleValue = this.options?.uiSchema?.title || this.options?.title || this.options.name;
-    return this.flowEngine.translate(titleValue);
+    const titleValue = this.options?.uiSchema?.title || this.options?.title;
+    return this.flowEngine.translate(titleValue, { ns: 'lm-collections' }) || this.options.name;
   }
 
   set title(value: string) {
@@ -820,11 +789,17 @@ export class CollectionField {
         }
         return {
           ...v,
+          label: v.label ? this.flowEngine.translate(v.label, { ns: 'lm-collections' }) : v.label,
           value: Number(v.value),
         };
       });
     }
-    return options;
+    return options.map((v) => {
+      return {
+        ...v,
+        label: this.flowEngine.translate(v.label, { ns: 'lm-collections' }),
+      };
+    });
   }
 
   get defaultValue() {

package/src/executor/FlowExecutor.ts

@@ -17,10 +17,20 @@ import { FlowExitException, resolveDefaultParams } from '../utils';
 import { FlowExitAllException } from '../utils/exceptions';
 import { setupRuntimeContextSteps } from '../utils/setupRuntimeContextSteps';
 import { createEphemeralContext } from '../utils/createEphemeralContext';
+import type { ScheduledCancel } from '../scheduler/ModelOperationScheduler';
 
 export class FlowExecutor {
   constructor(private readonly engine: FlowEngine) {}
 
+  private async emitModelEventIf(
+    eventName: string | undefined,
+    topic: string,
+    payload: Record<string, any>,
+  ): Promise<void> {
+    if (!eventName) return;
+    await this.engine.emitter.emitAsync(`model:event:${eventName}:${topic}`, payload);
+  }
+
   /** Cache wrapper for applyFlow cache lifecycle */
   private async withApplyFlowCache<T>(cacheKey: string | null, executor: () => Promise<T>): Promise<T> {
     if (!cacheKey || !this.engine) return await executor();
@@ -57,7 +67,13 @@ export class FlowExecutor {
   /**
    * Execute a single flow on model.
    */
-  async runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string): Promise<any> {
+  async runFlow(
+    model: FlowModel,
+    flowKey: string,
+    inputArgs?: Record<string, any>,
+    runId?: string,
+    eventName?: string,
+  ): Promise<any> {
     const flow = model.getFlow(flowKey);
 
     if (!flow) {
@@ -99,6 +115,16 @@ export class FlowExecutor {
     setupRuntimeContextSteps(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps as Record<string, { params: any; uiSchema?: any; result?: any }>;
 
+    const flowEventBasePayload = {
+      uid: model.uid,
+      model,
+      runId: flowContext.runId,
+      inputArgs,
+      flowKey,
+    };
+
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:start`, flowEventBasePayload);
+
     for (const [stepKey, step] of Object.entries(stepDefs) as [string, StepDefinition][]) {
       // Resolve handler and params
       let handler: ActionDefinition<FlowModel, FlowRuntimeContext>['handler'] | undefined;
@@ -156,6 +182,11 @@ export class FlowExecutor {
           );
           continue;
         }
+
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:start`, {
+          ...flowEventBasePayload,
+          stepKey,
+        });
         const currentStepResult = handler(runtimeCtx, combinedParams);
         const isAwait = step.isAwait !== false;
         lastResult = isAwait ? await currentStepResult : currentStepResult;
@@ -163,15 +194,47 @@ export class FlowExecutor {
         // Store step result and update context
         stepResults[stepKey] = lastResult;
         stepsRuntime[stepKey].result = stepResults[stepKey];
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+          ...flowEventBasePayload,
+          result: lastResult,
+          stepKey,
+        });
       } catch (error) {
+        if (!(error instanceof FlowExitException) && !(error instanceof FlowExitAllException)) {
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:error`, {
+            ...flowEventBasePayload,
+            error,
+            stepKey,
+          });
+        }
         if (error instanceof FlowExitException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey,
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: stepResults,
+          });
           return Promise.resolve(stepResults);
         }
         if (error instanceof FlowExitAllException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey,
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: error,
+          });
           return Promise.resolve(error);
         }
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:error`, {
+          ...flowEventBasePayload,
+          error,
+        });
         flowContext.logger.error(
           { err: error },
           `BaseModel.applyFlow: Error executing step '${stepKey}' in flow '${flowKey}':`,
@@ -179,11 +242,13 @@ export class FlowExecutor {
         return Promise.reject(error);
       }
     }
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+      ...flowEventBasePayload,
+      result: stepResults,
+    });
     return Promise.resolve(stepResults);
   }
 
-  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
-
   /**
    * Dispatch an event to flows bound via flow.on and execute them.
    */
@@ -202,14 +267,15 @@ export class FlowExecutor {
 
     const runId = `${model.uid}-${eventName}-${Date.now()}`;
     const logger = model.context.logger;
+    const eventBasePayload = {
+      uid: model.uid,
+      model,
+      runId,
+      inputArgs,
+    };
 
     try {
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:start`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
-      });
+      await this.emitModelEventIf(eventName, 'start', eventBasePayload);
       await model.onDispatchEventStart?.(eventName, options, inputArgs);
     } catch (err) {
       if (isBeforeRender && err instanceof FlowExitException) {
@@ -237,11 +303,25 @@ export class FlowExecutor {
           return false;
         });
 
+    // 路由系统的“重放打开视图”会再次 dispatchEvent('click')，但这不应重复触发用户配置的动态事件流。
+    // 约定：由路由重放触发时，会在 inputArgs 中携带 triggerByRouter: true
+    const isRouterReplayClick = eventName === 'click' && inputArgs?.triggerByRouter === true;
+    const flowsToRun = isRouterReplayClick
+      ? flows.filter((flow) => {
+          const reg = flow['flowRegistry'] as any;
+          const type = reg?.constructor?._type as 'instance' | 'global' | undefined;
+          return type !== 'instance';
+        })
+      : flows;
+
+    // 记录本次 dispatchEvent 内注册的调度任务，用于在结束/错误后兜底清理未触发的任务
+    const scheduledCancels: ScheduledCancel[] = [];
+
     // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
     const execute = async () => {
       if (sequential) {
         // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
-        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex
           .slice()
           .sort((a, b) => {
@@ -259,18 +339,116 @@ export class FlowExecutor {
           })
           .map((x) => x.f);
         const results: any[] = [];
+
+        // 预处理：当事件流配置了 on.phase 时，将其执行移动到指定节点，并从“立即执行列表”中移除
+        const staticFlowsByKey = new Map(
+          ordered
+            .filter((f) => {
+              const reg = f['flowRegistry'] as any;
+              const type = reg?.constructor?._type as 'instance' | 'global' | undefined;
+              return type !== 'instance';
+            })
+            .map((f) => [f.key, f] as const),
+        );
+        const scheduled = new Set<string>();
+        const scheduleGroups = new Map<string, Array<{ flow: any; order: number }>>();
+        ordered.forEach((flow, indexInOrdered) => {
+          const on = flow.on;
+          const onObj = typeof on === 'object' ? (on as any) : undefined;
+          if (!onObj) return;
+
+          const phase: any = onObj.phase;
+          const flowKey: any = onObj.flowKey;
+          const stepKey: any = onObj.stepKey;
+
+          // 默认：beforeAllFlows（保持现有行为）
+          if (!phase || phase === 'beforeAllFlows') return;
+
+          let whenKey: string | null = null;
+          if (phase === 'afterAllFlows') {
+            whenKey = `event:${eventName}:end`;
+          } else if (phase === 'beforeFlow' || phase === 'afterFlow') {
+            if (!flowKey) {
+              // 配置不完整：降级到“全部静态流之后”
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              if (anchorFlow) {
+                const anchorPhase = phase === 'beforeFlow' ? 'start' : 'end';
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:${anchorPhase}`;
+              } else {
+                // 锚点不存在（flow 被删除或覆盖等）：降级到“全部静态流之后”
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else if (phase === 'beforeStep' || phase === 'afterStep') {
+            if (!flowKey || !stepKey) {
+              // 配置不完整：降级到“全部静态流之后”
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              const anchorStepExists = !!anchorFlow?.hasStep?.(String(stepKey));
+              if (anchorFlow && anchorStepExists) {
+                const anchorPhase = phase === 'beforeStep' ? 'start' : 'end';
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:step:${String(stepKey)}:${anchorPhase}`;
+              } else {
+                // 锚点不存在（flow/step 被删除或覆盖等）：降级到“全部静态流之后”
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else {
+            // 未知 phase：忽略
+            return;
+          }
+
+          if (!whenKey) return;
+          scheduled.add(flow.key);
+          const list = scheduleGroups.get(whenKey) || [];
+          list.push({ flow, order: indexInOrdered });
+          scheduleGroups.set(whenKey, list);
+        });
+
+        // 注册调度（同锚点按 flow.sort 升序；sort 相同保持稳定顺序）
+        for (const [whenKey, list] of scheduleGroups.entries()) {
+          const sorted = list.slice().sort((a, b) => {
+            const sa = a.flow.sort ?? 0;
+            const sb = b.flow.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.order - b.order;
+          });
+          for (const it of sorted) {
+            const cancel = model.scheduleModelOperation(
+              model.uid,
+              async (m) => {
+                const res = await this.runFlow(m, it.flow.key, inputArgs, runId, eventName);
+                if (res instanceof FlowExitAllException) {
+                  throw res;
+                }
+                results.push(res);
+              },
+              { when: whenKey as any },
+            );
+            scheduledCancels.push(cancel);
+          }
+        }
+
         for (const flow of ordered) {
+          if (scheduled.has(flow.key)) continue;
           try {
             logger.debug(
               `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`,
             );
-            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
               break; // 终止后续
             }
             results.push(result);
           } catch (error) {
+            if (error instanceof FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              break; // 终止后续
+            }
             logger.error(
               { err: error },
               `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`,
@@ -283,10 +461,10 @@ export class FlowExecutor {
 
       // 并行
       const results = await Promise.all(
-        flows.map(async (flow) => {
+        flowsToRun.map(async (flow) => {
           logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
           try {
-            return await this.runFlow(model, flow.key, inputArgs, runId);
+            return await this.runFlow(model, flow.key, inputArgs, runId, eventName);
           } catch (error) {
             logger.error(
               { err: error },
@@ -318,11 +496,8 @@ export class FlowExecutor {
       } catch (hookErr) {
         logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
       }
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:end`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
+      await this.emitModelEventIf(eventName, 'end', {
+        ...eventBasePayload,
         result,
       });
       return result;
@@ -337,14 +512,16 @@ export class FlowExecutor {
         { err: error },
         `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`,
       );
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:error`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
+      await this.emitModelEventIf(eventName, 'error', {
+        ...eventBasePayload,
         error,
       });
       if (throwOnError) throw error;
+    } finally {
+      // 清理未触发的调度任务，避免跨事件/跨 runId 残留导致意外执行
+      for (const cancel of scheduledCancels) {
+        cancel();
+      }
     }
   }
 }

package/src/executor/__tests__/flowExecutor.test.ts

@@ -139,6 +139,72 @@ describe('FlowExecutor', () => {
     expect(submitHandler).not.toHaveBeenCalled();
   });
 
+  it("dispatchEvent('click') skips instance flows when triggerByRouter is true", async () => {
+    class MyModel extends FlowModel {}
+
+    const globalHandler = vi.fn().mockResolvedValue('global-ok');
+    MyModel.registerFlow('globalClick', {
+      on: 'click',
+      steps: {
+        s: { handler: globalHandler },
+      },
+    });
+
+    const instanceHandler = vi.fn().mockResolvedValue('instance-ok');
+    const model = new MyModel({
+      uid: 'm-click-router-replay',
+      flowEngine: engine,
+      flowRegistry: {
+        instanceClick: {
+          on: 'click',
+          steps: {
+            s: { handler: instanceHandler },
+          },
+        },
+      },
+      stepParams: {},
+      subModels: {},
+    } as FlowModelOptions);
+
+    await engine.executor.dispatchEvent(model, 'click', { triggerByRouter: true }, { sequential: true });
+
+    expect(globalHandler).toHaveBeenCalledTimes(1);
+    expect(instanceHandler).not.toHaveBeenCalled();
+  });
+
+  it("dispatchEvent('click') keeps instance flows when triggerByRouter is not true", async () => {
+    class MyModel extends FlowModel {}
+
+    const globalHandler = vi.fn().mockResolvedValue('global-ok');
+    MyModel.registerFlow('globalClick', {
+      on: 'click',
+      steps: {
+        s: { handler: globalHandler },
+      },
+    });
+
+    const instanceHandler = vi.fn().mockResolvedValue('instance-ok');
+    const model = new MyModel({
+      uid: 'm-click-normal',
+      flowEngine: engine,
+      flowRegistry: {
+        instanceClick: {
+          on: 'click',
+          steps: {
+            s: { handler: instanceHandler },
+          },
+        },
+      },
+      stepParams: {},
+      subModels: {},
+    } as FlowModelOptions);
+
+    await engine.executor.dispatchEvent(model, 'click', { triggerByRouter: false }, { sequential: true });
+
+    expect(globalHandler).toHaveBeenCalledTimes(1);
+    expect(instanceHandler).toHaveBeenCalledTimes(1);
+  });
+
   it('dispatchEvent default parallel does not stop on exitAll', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, opts?: { exitAll?: boolean }) => ({