@nocobase/flow-engine 2.0.7 → 2.0.9

package/lib/executor/FlowExecutor.js

@@ -213,11 +213,13 @@ const _FlowExecutor = class _FlowExecutor {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
           await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
             ...flowEventBasePayload,
-            stepKey
+            stepKey,
+            aborted: true
           });
           await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
             ...flowEventBasePayload,
-            result: error
+            result: error,
+            aborted: true
           });
           return Promise.resolve(error);
         }
@@ -287,6 +289,7 @@ const _FlowExecutor = class _FlowExecutor {
     }) : flows;
     const scheduledCancels = [];
     const execute = /* @__PURE__ */ __name(async () => {
+      let abortedByExitAll = false;
       if (sequential) {
         const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex.slice().sort((a, b) => {
@@ -355,9 +358,10 @@ const _FlowExecutor = class _FlowExecutor {
             return;
           }
           if (!whenKey) return;
+          const shouldSkipOnAborted = whenKey === `event:${eventName}:end` || phase === "afterFlow" || phase === "afterStep";
           scheduled.add(flow.key);
           const list = scheduleGroups.get(whenKey) || [];
-          list.push({ flow, order: indexInOrdered });
+          list.push({ flow, order: indexInOrdered, shouldSkipOnAborted });
           scheduleGroups.set(whenKey, list);
         });
         for (const [whenKey, list] of scheduleGroups.entries()) {
@@ -368,6 +372,12 @@ const _FlowExecutor = class _FlowExecutor {
             return a.order - b.order;
           });
           for (const it of sorted) {
+            const when = it.shouldSkipOnAborted ? Object.assign(
+              (event) => event.type === whenKey && event.aborted !== true,
+              {
+                __eventType: whenKey
+              }
+            ) : whenKey;
             const cancel = model.scheduleModelOperation(
               model.uid,
               async (m) => {
@@ -377,7 +387,7 @@ const _FlowExecutor = class _FlowExecutor {
                 }
                 results2.push(res);
               },
-              { when: whenKey }
+              { when }
             );
             scheduledCancels.push(cancel);
           }
@@ -391,12 +401,14 @@ const _FlowExecutor = class _FlowExecutor {
             const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              abortedByExitAll = true;
               break;
             }
             results2.push(result);
           } catch (error) {
             if (error instanceof import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              abortedByExitAll = true;
               break;
             }
             logger.error(
@@ -406,7 +418,7 @@ const _FlowExecutor = class _FlowExecutor {
             throw error;
           }
         }
-        return results2;
+        return { result: results2, abortedByExitAll };
       }
       const results = await Promise.all(
         flowsToRun.map(async (flow) => {
@@ -423,7 +435,11 @@ const _FlowExecutor = class _FlowExecutor {
           }
         })
       );
-      return results.filter((x) => x !== void 0);
+      const filteredResults = results.filter((x) => x !== void 0);
+      if (filteredResults.some((x) => x instanceof import_exceptions.FlowExitAllException)) {
+        abortedByExitAll = true;
+      }
+      return { result: filteredResults, abortedByExitAll };
     }, "execute");
     const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : "";
     const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(
@@ -432,7 +448,7 @@ const _FlowExecutor = class _FlowExecutor {
       model.uid
     ) : null;
     try {
-      const result = await this.withApplyFlowCache(cacheKey, execute);
+      const { result, abortedByExitAll } = await this.withApplyFlowCache(cacheKey, execute);
       try {
         await ((_c = model.onDispatchEventEnd) == null ? void 0 : _c.call(model, eventName, options, inputArgs, result));
       } catch (hookErr) {
@@ -440,7 +456,8 @@ const _FlowExecutor = class _FlowExecutor {
       }
       await this.emitModelEventIf(eventName, "end", {
         ...eventBasePayload,
-        result
+        result,
+        ...abortedByExitAll ? { aborted: true } : {}
       });
       return result;
     } catch (error) {

package/lib/scheduler/ModelOperationScheduler.d.ts

@@ -9,7 +9,10 @@
 import type { FlowEngine } from '../flowEngine';
 import type { FlowModel } from '../models/flowModel';
 type LifecycleType = 'created' | 'mounted' | 'unmounted' | 'destroyed' | `event:${string}:start` | `event:${string}:end` | `event:${string}:error`;
-export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+type EventPredicateWhen = ((e: LifecycleEvent) => boolean) & {
+    __eventType?: string;
+};
+export type ScheduleWhen = LifecycleType | EventPredicateWhen;
 export interface ScheduleOptions {
     when?: ScheduleWhen;
 }
@@ -22,6 +25,7 @@ export interface LifecycleEvent {
     error?: any;
     inputArgs?: Record<string, any>;
     result?: any;
+    aborted?: boolean;
     flowKey?: string;
     stepKey?: string;
 }

package/lib/scheduler/ModelOperationScheduler.js

@@ -171,8 +171,9 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
     this.unbindHandlers.push(() => emitter.off("model:destroyed", onDestroyed));
   }
   ensureEventSubscriptionIfNeeded(when) {
-    if (!when || typeof when !== "string") return;
-    const parsed = this.parseEventWhen(when);
+    const eventType = typeof when === "string" ? when : typeof when === "function" ? when.__eventType : void 0;
+    if (!eventType) return;
+    const parsed = this.parseEventWhen(eventType);
     if (!parsed) return;
     const { name } = parsed;
     if (this.subscribedEventNames.has(name)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "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.7",
-    "@nocobase/shared": "2.0.7",
+    "@nocobase/sdk": "2.0.9",
+    "@nocobase/shared": "2.0.9",
     "ahooks": "^3.7.2",
     "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
@@ -36,5 +36,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "71519f094dea3451ddfebe0045d8fd6e4281a6c5"
+  "gitHead": "bbbfb42c1a0116d9b665d43ee71688c1fdfd84f6"
 }

package/src/executor/FlowExecutor.ts

@@ -224,10 +224,12 @@ export class FlowExecutor {
           await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
             ...flowEventBasePayload,
             stepKey,
+            aborted: true,
           });
           await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
             ...flowEventBasePayload,
             result: error,
+            aborted: true,
           });
           return Promise.resolve(error);
         }
@@ -316,9 +318,9 @@ export class FlowExecutor {
 
     // 记录本次 dispatchEvent 内注册的调度任务，用于在结束/错误后兜底清理未触发的任务
     const scheduledCancels: ScheduledCancel[] = [];
-
-    // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
-    const execute = async () => {
+    // 组装执行函数（返回值用于缓存，包含事件结果与是否被 exitAll 中止）
+    const execute = async (): Promise<{ result: any[]; abortedByExitAll: boolean }> => {
+      let abortedByExitAll = false;
       if (sequential) {
         // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
         const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
@@ -351,7 +353,7 @@ export class FlowExecutor {
             .map((f) => [f.key, f] as const),
         );
         const scheduled = new Set<string>();
-        const scheduleGroups = new Map<string, Array<{ flow: any; order: number }>>();
+        const scheduleGroups = new Map<string, Array<{ flow: any; order: number; shouldSkipOnAborted: boolean }>>();
         ordered.forEach((flow, indexInOrdered) => {
           const on = flow.on;
           const onObj = typeof on === 'object' ? (on as any) : undefined;
@@ -402,9 +404,11 @@ export class FlowExecutor {
           }
 
           if (!whenKey) return;
+          const shouldSkipOnAborted =
+            whenKey === `event:${eventName}:end` || phase === 'afterFlow' || phase === 'afterStep';
           scheduled.add(flow.key);
           const list = scheduleGroups.get(whenKey) || [];
-          list.push({ flow, order: indexInOrdered });
+          list.push({ flow, order: indexInOrdered, shouldSkipOnAborted });
           scheduleGroups.set(whenKey, list);
         });
 
@@ -417,6 +421,14 @@ export class FlowExecutor {
             return a.order - b.order;
           });
           for (const it of sorted) {
+            const when = it.shouldSkipOnAborted
+              ? Object.assign(
+                  (event: { type: string; aborted?: boolean }) => event.type === whenKey && event.aborted !== true,
+                  {
+                    __eventType: whenKey,
+                  },
+                )
+              : (whenKey as any);
             const cancel = model.scheduleModelOperation(
               model.uid,
               async (m) => {
@@ -426,7 +438,7 @@ export class FlowExecutor {
                 }
                 results.push(res);
               },
-              { when: whenKey as any },
+              { when },
             );
             scheduledCancels.push(cancel);
           }
@@ -441,12 +453,14 @@ export class FlowExecutor {
             const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              abortedByExitAll = true;
               break; // 终止后续
             }
             results.push(result);
           } catch (error) {
             if (error instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              abortedByExitAll = true;
               break; // 终止后续
             }
             logger.error(
@@ -456,7 +470,7 @@ export class FlowExecutor {
             throw error;
           }
         }
-        return results;
+        return { result: results, abortedByExitAll };
       }
 
       // 并行
@@ -475,7 +489,11 @@ export class FlowExecutor {
           }
         }),
       );
-      return results.filter((x) => x !== undefined);
+      const filteredResults = results.filter((x) => x !== undefined);
+      if (filteredResults.some((x) => x instanceof FlowExitAllException)) {
+        abortedByExitAll = true;
+      }
+      return { result: filteredResults, abortedByExitAll };
     };
 
     // 缓存键：按事件+scope 统一管理（beforeRender 也使用事件名 beforeRender）
@@ -489,7 +507,7 @@ export class FlowExecutor {
       : null;
 
     try {
-      const result = await this.withApplyFlowCache(cacheKey, execute);
+      const { result, abortedByExitAll } = await this.withApplyFlowCache(cacheKey, execute);
       // 事件结束钩子
       try {
         await model.onDispatchEventEnd?.(eventName, options, inputArgs, result);
@@ -499,6 +517,7 @@ export class FlowExecutor {
       await this.emitModelEventIf(eventName, 'end', {
         ...eventBasePayload,
         result,
+        ...(abortedByExitAll ? { aborted: true } : {}),
       });
       return result;
     } catch (error) {

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

@@ -288,6 +288,32 @@ describe('FlowExecutor', () => {
     expect(handler).toHaveBeenCalledTimes(2); // 每个 flow 各 1 次，共 2 次
   });
 
+  it("dispatchEvent('beforeRender') keeps aborted flag on end event when cache hits", async () => {
+    const handler = vi.fn().mockImplementation((ctx) => {
+      ctx.exitAll();
+    });
+    const flows = {
+      abortFlow: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-br-cache-aborted', flows);
+
+    const endEvents: any[] = [];
+    const onEnd = (payload: any) => {
+      endEvents.push(payload);
+    };
+    engine.emitter.on('model:event:beforeRender:end', onEnd);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    engine.emitter.off('model:event:beforeRender:end', onEnd);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(endEvents).toHaveLength(2);
+    expect(endEvents[0]?.aborted).toBe(true);
+    expect(endEvents[1]?.aborted).toBe(true);
+  });
+
   it('dispatchEvent supports sequential execution order and exitAll break', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number, opts?: { exitAll?: boolean }) => ({

package/src/models/__tests__/dispatchEvent.when.test.ts

@@ -105,6 +105,45 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic']);
   });
 
+  test("phase='afterAllFlows': skips when event aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      sort: -10,
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            calls.push('abort');
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('AfterAll', {
+      on: { eventName: 'go', phase: 'afterAllFlows' },
+      steps: {
+        d: { handler: async () => void calls.push('after-all') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['abort']);
+  });
+
   test("phase='beforeFlow': instance flow runs before the target static flow", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -161,6 +200,39 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'static-b', 'dynamic']);
   });
 
+  test("phase='afterFlow': skips when anchor flow is aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            calls.push('static-a');
+            ctx.exitAll();
+          },
+        } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterFlow', flowKey: 'S' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a']);
+  });
+
   test("phase='beforeStep': instance flow runs before the target static step", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -217,6 +289,39 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic', 'static-b']);
   });
 
+  test("phase='afterStep': skips when anchor step is aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            calls.push('static-a');
+            ctx.exitAll();
+          },
+        } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a']);
+  });
+
   test("phase='beforeFlow': ctx.exitAll() stops anchor flow and subsequent flows", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -430,6 +535,115 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic']);
   });
 
+  test('fallback to event:end (missing anchor) skips when event aborted by ctx.exitAll()', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      sort: -10,
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            calls.push('abort');
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('FallbackToEnd', {
+      on: { eventName: 'go', phase: 'beforeFlow', flowKey: 'missing' },
+      steps: {
+        d: { handler: async () => void calls.push('fallback-end') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['abort']);
+  });
+
+  test('event:end is still emitted with aborted=true when exitAll happens', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const endEvents: any[] = [];
+    const onEnd = (payload: any) => {
+      endEvents.push(payload);
+    };
+    engine.emitter.on('model:event:go:end', onEnd);
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    engine.emitter.off('model:event:go:end', onEnd);
+
+    expect(endEvents).toHaveLength(1);
+    expect(endEvents[0]?.aborted).toBe(true);
+  });
+
+  test('flow:end/step:end are emitted with aborted=true when exitAll happens', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const flowEndEvents: any[] = [];
+    const stepEndEvents: any[] = [];
+    const onFlowEnd = (payload: any) => {
+      flowEndEvents.push(payload);
+    };
+    const onStepEnd = (payload: any) => {
+      stepEndEvents.push(payload);
+    };
+    engine.emitter.on('model:event:go:flow:S:end', onFlowEnd);
+    engine.emitter.on('model:event:go:flow:S:step:a:end', onStepEnd);
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    await model.dispatchEvent('go');
+
+    engine.emitter.off('model:event:go:flow:S:end', onFlowEnd);
+    engine.emitter.off('model:event:go:flow:S:step:a:end', onStepEnd);
+
+    expect(flowEndEvents).toHaveLength(1);
+    expect(stepEndEvents).toHaveLength(1);
+    expect(flowEndEvents[0]?.aborted).toBe(true);
+    expect(stepEndEvents[0]?.aborted).toBe(true);
+  });
+
   test('multiple flows on same anchor: executes by flow.sort asc (stable)', async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}

package/src/scheduler/ModelOperationScheduler.ts

@@ -21,7 +21,11 @@ type LifecycleType =
   | `event:${string}:end`
   | `event:${string}:error`;
 
-export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+type EventPredicateWhen = ((e: LifecycleEvent) => boolean) & {
+  __eventType?: string;
+};
+
+export type ScheduleWhen = LifecycleType | EventPredicateWhen;
 
 export interface ScheduleOptions {
   when?: ScheduleWhen;
@@ -37,6 +41,7 @@ export interface LifecycleEvent {
   error?: any;
   inputArgs?: Record<string, any>;
   result?: any;
+  aborted?: boolean;
   flowKey?: string;
   stepKey?: string;
 }
@@ -216,8 +221,14 @@ export class ModelOperationScheduler {
   }
 
   private ensureEventSubscriptionIfNeeded(when?: ScheduleWhen) {
-    if (!when || typeof when !== 'string') return;
-    const parsed = this.parseEventWhen(when);
+    const eventType =
+      typeof when === 'string'
+        ? when
+        : typeof when === 'function'
+          ? (when as EventPredicateWhen).__eventType
+          : undefined;
+    if (!eventType) return;
+    const parsed = this.parseEventWhen(eventType as ScheduleWhen);
     if (!parsed) return;
     const { name } = parsed;
     if (this.subscribedEventNames.has(name)) return;