@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.41

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

@@ -81,7 +81,7 @@ describe('FlowExecutor', () => {
     expect(result.step2).toBe('step2-ok');
   });
 
-  it('runAutoFlows executes only auto flows in sort order and caches result', async () => {
+  it("dispatchEvent('beforeRender') executes flows in sort order and caches result (when options specify)", async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number) => ({
       sort,
@@ -104,15 +104,21 @@ describe('FlowExecutor', () => {
 
     const model = createModelWithFlows('m-auto', flows);
 
-    const r1 = await engine.executor.runAutoFlows(model);
-    expect(r1).toHaveLength(2);
+    const r1 = await engine.executor.dispatchEvent(model, 'beforeRender', undefined, {
+      sequential: true,
+      useCache: true,
+    });
+    expect(Array.isArray(r1)).toBe(true);
     // sort order: f1 then f2
     expect(calls).toEqual(['f1', 'f2']);
 
     // second run should hit cache and not execute handlers again
     const prevCount = calls.length;
-    const r2 = await engine.executor.runAutoFlows(model);
-    expect(r2).toEqual(r1);
+    const r2 = await engine.executor.dispatchEvent(model, 'beforeRender', undefined, {
+      sequential: true,
+      useCache: true,
+    });
+    expect(Array.isArray(r2)).toBe(true);
     expect(calls.length).toBe(prevCount);
   });
 
@@ -133,6 +139,146 @@ describe('FlowExecutor', () => {
     expect(submitHandler).not.toHaveBeenCalled();
   });
 
+  it('dispatchEvent default parallel does not stop on exitAll', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, opts?: { exitAll?: boolean }) => ({
+      on: { eventName: 'par' },
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation((ctx) => {
+            calls.push(key);
+            if (opts?.exitAll) ctx.exitAll();
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      a: mkFlow('a', { exitAll: true }),
+      b: mkFlow('b'),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-par', flows);
+
+    await engine.executor.dispatchEvent(model, 'par');
+
+    // 在并行模式下，b 不会被 exitAll 中断
+    expect(calls.sort()).toEqual(['a', 'b']);
+  });
+
+  it('dispatchEvent sequential respects sort order and stops on errors', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, sort: number, opts?: { throw?: boolean }) => ({
+      on: { eventName: 'seq2' },
+      sort,
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation(() => {
+            calls.push(key);
+            if (opts?.throw) throw new Error('boom');
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      f2: mkFlow('f2', 2),
+      f1: mkFlow('f1', 1, { throw: true }),
+      f3: mkFlow('f3', 3),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-seq2', flows);
+    await engine.executor.dispatchEvent(model, 'seq2', {}, { sequential: true });
+
+    // 顺序：按 sort 执行；f1 抛错后终止，f2 和 f3 不会执行
+    expect(calls).toEqual(['f1']);
+  });
+
+  it('dispatchEvent caches non-beforeRender when useCache=true', async () => {
+    const handler = vi.fn();
+    const flows = {
+      onFoo: { on: 'foo', steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-evt-cache', flows);
+
+    await engine.executor.dispatchEvent(model, 'foo', {}, { useCache: true });
+    await engine.executor.dispatchEvent(model, 'foo', {}, { useCache: true });
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatchEvent('beforeRender') runs once due to cache (when options specify)", async () => {
+    const handler = vi.fn();
+    const flows = {
+      auto1: { steps: { s: { handler } } }, // 无 on → 视为 beforeRender
+      auto2: { on: 'beforeRender', steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-br-cache', flows);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    // 两次触发但步骤处理只执行一次（命中缓存）
+    expect(handler).toHaveBeenCalledTimes(2); // 每个 flow 各 1 次，共 2 次
+  });
+
+  it('dispatchEvent supports sequential execution order and exitAll break', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, sort: number, opts?: { exitAll?: boolean }) => ({
+      on: { eventName: 'seq' },
+      sort,
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation((ctx) => {
+            calls.push(key);
+            if (opts?.exitAll) ctx.exitAll();
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      f1: mkFlow('f1', 1, { exitAll: true }),
+      f2: mkFlow('f2', 2),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-seq', flows);
+
+    await engine.executor.dispatchEvent(model, 'seq', {}, { sequential: true });
+
+    // f1 executed then exitAll stops f2
+    expect(calls).toEqual(['f1']);
+  });
+
+  it("dispatchEvent('beforeRender') caches results (key includes eventName) when options specify", async () => {
+    const handler = vi.fn().mockResolvedValue('ok');
+    const flows = {
+      f1: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-br', flows);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    // handler only executed once because of cache
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatchEvent('beforeRender') rejects when a step throws", async () => {
+    const handler = vi.fn().mockImplementation(() => {
+      throw new Error('boom-br');
+    });
+    const flows = {
+      bad: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-br-reject', flows);
+
+    await expect(engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true })).rejects.toThrow(
+      'boom-br',
+    );
+  });
+
   it('instance flow overrides global flow with same key', async () => {
     class MyModel extends FlowModel {}
 

package/src/flow-registry/GlobalFlowRegistry.ts

@@ -15,6 +15,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 
 export class GlobalFlowRegistry extends BaseFlowRegistry {
+  static readonly _type = 'global' as const;
   constructor(protected target: ModelConstructor) {
     super();
   }

package/src/flow-registry/InstanceFlowRegistry.ts

@@ -14,6 +14,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 
 export class InstanceFlowRegistry extends BaseFlowRegistry {
+  static readonly _type = 'instance' as const;
   constructor(protected model: FlowModel) {
     super();
   }

package/src/flow-registry/__tests__/globalFlowRegistry.test.ts

@@ -138,4 +138,58 @@ describe('GlobalFlowRegistry', () => {
     expect(staticHandler).toHaveBeenCalled();
     expect(instanceHandler).toHaveBeenCalled();
   });
+
+  test('getFlows returns instance (dynamic) flows before static flows with own internal ordering', () => {
+    const engine = new FlowEngine();
+    class OrderModel extends FlowModel {}
+    engine.registerModels({ OrderModel });
+
+    // Register static flows with various sort values
+    OrderModel.registerFlow({ key: 'staticLow', title: 'S-low', sort: -10, steps: {} });
+    OrderModel.registerFlow({ key: 'staticHigh', title: 'S-high', sort: 10, steps: {} });
+
+    const model = engine.createModel({ use: 'OrderModel' });
+
+    // Add instance flows with sort values that would normally interleave if sorted purely by sort
+    model.flowRegistry.addFlow('instMid', { title: 'I-mid', sort: 0, steps: {} });
+    model.flowRegistry.addFlow('instHigh', { title: 'I-high', sort: 5, steps: {} });
+
+    const keys = Array.from(model.getFlows().keys());
+    // Expect dynamic flows first (by sort inside group), then static flows (by their own ordering)
+    expect(keys).toEqual(['instMid', 'instHigh', 'staticLow', 'staticHigh']);
+  });
+
+  test('sequential dispatch runs instance flows before static flows regardless of static sort', async () => {
+    const engine = new FlowEngine();
+    class SeqModel extends FlowModel {}
+    engine.registerModels({ SeqModel });
+
+    const calls: string[] = [];
+
+    // Static flow with very low sort to try to run first if not grouped
+    SeqModel.registerFlow({
+      key: 'S',
+      on: { eventName: 'click' },
+      sort: -100,
+      steps: { s: { handler: async () => void calls.push('static') } as any },
+    });
+
+    const model = engine.createModel({ use: 'SeqModel' });
+
+    // Instance flows with sort greater than static
+    model.flowRegistry.addFlow('I1', {
+      on: { eventName: 'click' },
+      sort: 0,
+      steps: { i1: { handler: async () => void calls.push('inst1') } as any },
+    });
+    model.flowRegistry.addFlow('I2', {
+      on: { eventName: 'click' },
+      sort: 5,
+      steps: { i2: { handler: async () => void calls.push('inst2') } as any },
+    });
+
+    await model.dispatchEvent('click', undefined, { sequential: true });
+
+    expect(calls).toEqual(['inst1', 'inst2', 'static']);
+  });
 });