@nocobase/flow-engine 2.0.0-alpha.2

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

@@ -0,0 +1,157 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models';
+import type { FlowDefinitionOptions, FlowModelOptions } from '../../types';
+
+describe('FlowExecutor - event step integration', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  function createModelWithFlows(uid: string, flows: Record<string, Omit<FlowDefinitionOptions, 'key'>>) {
+    const model = new FlowModel({
+      uid,
+      flowEngine: engine,
+      stepParams: {},
+      subModels: {},
+      flowRegistry: flows,
+    } as FlowModelOptions);
+    return model;
+  }
+
+  it('executes event step first and can exit subsequent steps', async () => {
+    // Register an event with a handler that exits when allow=false
+    const eventHandler = vi.fn().mockImplementation((ctx, params: any) => {
+      if (params?.allow === false) ctx.exit();
+    });
+    engine.registerEvents({
+      click: {
+        name: 'click',
+        title: 'Click',
+        handler: eventHandler,
+      },
+    });
+
+    const nextStepHandler = vi.fn();
+
+    const flows = {
+      blocked: {
+        on: { eventName: 'click', defaultParams: { allow: false } },
+        steps: {
+          next: { handler: nextStepHandler },
+        },
+      },
+      allowed: {
+        on: { eventName: 'click', defaultParams: { allow: true } },
+        steps: {
+          next: { handler: nextStepHandler },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-events', flows);
+
+    // When allow=false, event step exits and subsequent steps should not run
+    await engine.executor.dispatchEvent(model, 'click');
+    expect(eventHandler).toHaveBeenCalled();
+    // Both flows fire, but only the second one should run next step
+    // nextStepHandler should be called exactly once for the 'allowed' flow
+    expect(nextStepHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it('merges on.defaultParams with event defaultParams (event takes precedence on conflicts)', async () => {
+    const receivedParams: any[] = [];
+    const eventHandler = vi.fn().mockImplementation((_ctx, params) => {
+      receivedParams.push(params);
+    });
+    engine.registerEvents({
+      click: {
+        name: 'click',
+        title: 'Click',
+        defaultParams: { a: 1, b: 2 },
+        handler: eventHandler,
+      },
+    });
+
+    const flows = {
+      f1: {
+        on: { eventName: 'click', defaultParams: { b: 99, c: 3 } },
+        steps: {
+          after: { handler: vi.fn() },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-merge', flows);
+    await engine.executor.runFlow(model, 'f1');
+
+    expect(eventHandler).toHaveBeenCalledTimes(1);
+    // event defaultParams override flow.on.defaultParams on same keys
+    expect(receivedParams[0]).toEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  it('event step runs before ordinary steps', async () => {
+    const calls: string[] = [];
+    const eventHandler = vi.fn().mockImplementation(() => {
+      calls.push('event');
+    });
+    const nextHandler = vi.fn().mockImplementation(() => {
+      calls.push('next');
+    });
+
+    engine.registerEvents({
+      click: { name: 'click', title: 'Click', handler: eventHandler },
+    });
+
+    const flows = {
+      f: {
+        on: { eventName: 'click' },
+        steps: {
+          next: { handler: nextHandler },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-order', flows);
+    await engine.executor.runFlow(model, 'f');
+
+    expect(eventHandler).toHaveBeenCalledTimes(1);
+    expect(nextHandler).toHaveBeenCalledTimes(1);
+    expect(calls).toEqual(['event', 'next']);
+  });
+
+  it('dispatchEvent triggers only flows that match event name', async () => {
+    const clickHandler = vi.fn();
+    const submitHandler = vi.fn();
+
+    engine.registerEvents({
+      click: { name: 'click', title: 'Click', handler: clickHandler },
+      submit: { name: 'submit', title: 'Submit', handler: submitHandler },
+    });
+
+    const flows = {
+      onClick: { on: { eventName: 'click' }, steps: { s: { handler: vi.fn() } } },
+      onSubmit: { on: { eventName: 'submit' }, steps: { s: { handler: vi.fn() } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-dispatch', flows);
+
+    await engine.executor.dispatchEvent(model, 'click');
+
+    expect(clickHandler).toHaveBeenCalledTimes(1);
+    expect(submitHandler).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,163 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models';
+import type { FlowDefinitionOptions, FlowModelOptions } from '../../types';
+
+describe('FlowExecutor', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  function createModelWithFlows(uid: string, flows: Record<string, Omit<FlowDefinitionOptions, 'key'>>) {
+    const model = new FlowModel({
+      uid,
+      flowEngine: engine,
+      stepParams: {},
+      subModels: {},
+      flowRegistry: flows,
+    } as FlowModelOptions);
+    return model;
+  }
+
+  it('runFlow executes steps and merges params from action/step/model', async () => {
+    const actionHandler = vi.fn((_ctx, params) => params);
+    engine.registerActions({
+      testAction: {
+        name: 'testAction',
+        handler: actionHandler,
+        defaultParams: { a: 1, b: 2 },
+      },
+    });
+
+    const step2Handler = vi.fn().mockResolvedValue('step2-ok');
+
+    const flows = {
+      testFlow: {
+        title: 'Test Flow',
+        steps: {
+          step1: {
+            use: 'testAction',
+            defaultParams: { b: 22, c: 3 },
+          },
+          step2: {
+            handler: step2Handler,
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = new FlowModel({
+      uid: 'm-runFlow',
+      flowEngine: engine,
+      stepParams: { testFlow: { step1: { b: 99, d: 4 } } },
+      subModels: {},
+      flowRegistry: flows,
+    } as FlowModelOptions);
+
+    const result = await engine.executor.runFlow(model, 'testFlow');
+
+    // step1 received merged params: action(a=1,b=2) + step(b=22,c=3) + model(b=99,d=4)
+    expect(actionHandler).toHaveBeenCalledTimes(1);
+    const [, receivedParams] = actionHandler.mock.calls[0];
+    expect(receivedParams).toEqual({ a: 1, b: 99, c: 3, d: 4 });
+
+    expect(step2Handler).toHaveBeenCalledTimes(1);
+
+    // result is stepResults map
+    expect(result).toBeDefined();
+    expect(result.step2).toBe('step2-ok');
+  });
+
+  it('runAutoFlows executes only auto flows in sort order and caches result', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, sort: number) => ({
+      sort,
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation(async () => {
+            calls.push(key);
+            return key;
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      f2: mkFlow('f2', 2),
+      f1: mkFlow('f1', 1),
+      ignoredManual: { manual: true, steps: { s: { handler: vi.fn() } } },
+      ignoredOn: { on: 'click', steps: { s: { handler: vi.fn() } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-auto', flows);
+
+    const r1 = await engine.executor.runAutoFlows(model);
+    expect(r1).toHaveLength(2);
+    // 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);
+    expect(calls.length).toBe(prevCount);
+  });
+
+  it('dispatchEvent triggers only flows matching event name', async () => {
+    const clickHandler = vi.fn().mockResolvedValue('ok-click');
+    const submitHandler = vi.fn().mockResolvedValue('ok-submit');
+
+    const flows = {
+      clickFlow: { on: { eventName: 'click' }, steps: { s: { handler: clickHandler } } },
+      submitFlow: { on: { eventName: 'submit' }, steps: { s: { handler: submitHandler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-dispatch', flows);
+
+    await engine.executor.dispatchEvent(model, 'click');
+
+    expect(clickHandler).toHaveBeenCalledTimes(1);
+    expect(submitHandler).not.toHaveBeenCalled();
+  });
+
+  it('instance flow overrides global flow with same key', async () => {
+    class MyModel extends FlowModel {}
+
+    // register a global flow on MyModel
+    MyModel.registerFlow('sameKey', {
+      title: 'Global Flow',
+      steps: {
+        s: { handler: vi.fn().mockResolvedValue('global') },
+      },
+    });
+
+    // create instance with same key overriding
+    const instanceHandler = vi.fn().mockResolvedValue('instance');
+    const model = new MyModel({
+      uid: 'm-combined',
+      flowEngine: engine,
+      flowRegistry: {
+        sameKey: { steps: { s: { handler: instanceHandler } } },
+      },
+      stepParams: {},
+      subModels: {},
+    } as FlowModelOptions);
+
+    const result = await engine.executor.runFlow(model, 'sameKey');
+    expect(instanceHandler).toHaveBeenCalledTimes(1);
+    expect(result.s).toBe('instance');
+  });
+});

package/src/flow-registry/BaseFlowRegistry.ts

@@ -0,0 +1,91 @@
+/**
+ * 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 { FlowDefinitionOptions } from '../types';
+import { FlowDefinition } from '../FlowDefinition';
+import { observable } from '@formily/reactive';
+
+type FlowKey = string;
+
+export interface IFlowRepository {
+  addFlows(flowDefs: Record<string, Omit<FlowDefinitionOptions, 'key'>>): void;
+  addFlow(flowKey: string, flowOptions: Omit<FlowDefinitionOptions, 'key'>): FlowDefinition | void;
+  removeFlow(flowKey: string): void;
+  getFlows(): Map<string, FlowDefinition>;
+  mapFlows<T = any>(callback: (flow: FlowDefinition) => T): T[];
+  hasFlow(flowKey: string): boolean;
+  getFlow(flowKey: string): FlowDefinition | undefined;
+  saveFlow(flow: FlowDefinition): Promise<any> | void;
+  destroyFlow(flowKey: string): Promise<any> | void;
+  moveStep(flowKey: string, sourceStepKey: string, targetStepKey: string): Promise<any> | void;
+}
+
+/**
+ * 抽象基类，封装通用的 Flow Registry 逻辑
+ * 子类只需实现持久化相关的方法
+ */
+export abstract class BaseFlowRegistry implements IFlowRepository {
+  protected flows: Map<FlowKey, FlowDefinition>;
+
+  constructor() {
+    this.flows = observable.shallow(new Map());
+  }
+
+  addFlows(flows: Record<FlowKey, Omit<FlowDefinitionOptions, 'key'> & { key?: string }>): void {
+    for (const [flowKey, flowOptions] of Object.entries(flows || {})) {
+      this.addFlow(flowKey, flowOptions);
+    }
+  }
+
+  addFlow(flowKey: FlowKey, flowOptions: Omit<FlowDefinitionOptions, 'key'> & { key?: string }): FlowDefinition {
+    const flow = new FlowDefinition(
+      {
+        ...flowOptions,
+        key: flowKey,
+      },
+      this,
+    );
+    this.flows.set(flowKey, flow);
+    return flow;
+  }
+
+  hasFlow(flowKey: FlowKey): boolean {
+    const flow = this.flows.get(flowKey);
+    return !!flow;
+  }
+
+  getFlow(flowKey: FlowKey): FlowDefinition | undefined {
+    return this.flows.get(flowKey);
+  }
+
+  getFlows(): Map<FlowKey, FlowDefinition> {
+    return this.flows;
+  }
+
+  removeFlow(flowKey: FlowKey): void {
+    this.flows.delete(flowKey);
+  }
+
+  mapFlows<T = any>(callback: (flow: FlowDefinition) => T): T[] {
+    const flows = this.getFlows();
+    return [...flows.values()].map((flow) => callback(flow));
+  }
+
+  moveStep(flowKey: FlowKey, sourceStepKey: string, targetStepKey: string): void {
+    const flow = this.getFlow(flowKey);
+    if (!flow) {
+      throw new Error(`Flow '${flowKey}' not found`);
+    }
+    flow.moveStep(sourceStepKey, targetStepKey);
+  }
+
+  // 抽象方法 - 子类必须实现持久化逻辑
+  abstract saveFlow(flow: FlowDefinition): Promise<any> | void;
+  abstract destroyFlow(flowKey: string): Promise<any> | void;
+}

package/src/flow-registry/GlobalFlowRegistry.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 { FlowDefinitionOptions, ModelConstructor } from '../types';
+import { FlowModel } from '../models';
+import { FlowDefinition } from '../FlowDefinition';
+import { BaseFlowRegistry } from './BaseFlowRegistry';
+
+type FlowKey = string;
+
+export class GlobalFlowRegistry extends BaseFlowRegistry {
+  constructor(protected target: ModelConstructor) {
+    super();
+  }
+
+  removeFlow(flowKey: FlowKey): void {
+    // Not supported yet for static flows; warn and noop
+    console.warn(`GlobalFlowRegistry.removeFlow: removing static flow '${flowKey}' is not supported.`);
+  }
+
+  getFlow(flowKey: FlowKey): FlowDefinition | undefined {
+    if (this.flows.has(flowKey)) {
+      return this.flows.get(flowKey);
+    }
+    const proto: typeof FlowModel | null = Object.getPrototypeOf(this.target);
+    if (proto !== Function.prototype && proto !== Object.prototype && proto?.globalFlowRegistry) {
+      return proto.globalFlowRegistry.getFlow(flowKey);
+    }
+    return undefined;
+  }
+
+  getFlows(): Map<FlowKey, FlowDefinition> {
+    const flows = new Map<FlowKey, FlowDefinition>(this.flows);
+    const proto: typeof FlowModel | null = Object.getPrototypeOf(this.target);
+    if (proto !== Function.prototype && proto !== Object.prototype && proto?.globalFlowRegistry) {
+      for (const [key, def] of proto.globalFlowRegistry.getFlows().entries()) {
+        if (!flows.has(key)) {
+          flows.set(key, def);
+        }
+      }
+    }
+
+    // 对静态流进行排序：按 sort 升序；sort 相同的情况下，父类静态流先于子类静态流
+    const getClassDepth = (klass: any): number => {
+      let depth = 0;
+      let cur = klass;
+      while (cur && cur !== FlowModel && cur !== Function.prototype && cur !== Object.prototype) {
+        cur = Object.getPrototypeOf(cur);
+        depth += 1;
+      }
+      return depth;
+    };
+
+    const sortedEntries = Array.from(flows.entries()).sort(([, a], [, b]) => {
+      const sa = a.sort ?? 0;
+      const sb = b.sort ?? 0;
+      if (sa !== sb) return sa - sb;
+      const ra = a['flowRegistry'];
+      const rb = b['flowRegistry'];
+      const da = getClassDepth(ra['target']);
+      const db = getClassDepth(rb['target']);
+      if (da !== db) return da - db; // 父类（深度更小）在前
+      return 0;
+    });
+
+    return new Map(sortedEntries);
+  }
+
+  saveFlow(flow: FlowDefinition): void {
+    // No-op for static flows
+  }
+
+  destroyFlow(flowKey: string): void {
+    // Static flows are class-level; no persistence. No-op.
+  }
+}

package/src/flow-registry/InstanceFlowRegistry.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+import { FlowModel } from '../models';
+import { BaseFlowRegistry } from './BaseFlowRegistry';
+
+type FlowKey = string;
+
+export class InstanceFlowRegistry extends BaseFlowRegistry {
+  constructor(protected model: FlowModel) {
+    super();
+  }
+
+  async save() {
+    await this.model.saveStepParams();
+  }
+
+  async saveFlow(flow: FlowDefinition): Promise<void> {
+    await this.model.saveStepParams();
+  }
+
+  async destroyFlow(flowKey: FlowKey): Promise<void> {
+    this.removeFlow(flowKey);
+    // TODO
+    await this.model.saveStepParams();
+  }
+
+  async moveStep(flowKey: FlowKey, sourceStepKey: string, targetStepKey: string): Promise<void> {
+    super.moveStep(flowKey, sourceStepKey, targetStepKey);
+    await this.model.saveStepParams();
+  }
+}

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

@@ -0,0 +1,141 @@
+/**
+ * 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 } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models/flowModel';
+import type { FlowDefinitionOptions } from '../../types';
+
+describe('GlobalFlowRegistry', () => {
+  test('registerFlow stores static flow on model class', () => {
+    class ParentModel extends FlowModel {}
+
+    const parentFlow: FlowDefinitionOptions = {
+      key: 'parentFlow',
+      title: 'Parent Flow',
+      steps: {
+        stepA: { title: 'A' } as any,
+      },
+    };
+
+    ParentModel.registerFlow(parentFlow);
+
+    const flow = ParentModel.globalFlowRegistry.getFlow('parentFlow');
+    expect(flow).toBeDefined();
+    expect(flow?.key).toBe('parentFlow');
+    expect(flow?.title).toBe('Parent Flow');
+    expect(flow?.getStep('stepA')?.serialize()).toEqual({ key: 'stepA', flowKey: 'parentFlow', title: 'A', sort: 1 });
+  });
+
+  test('saveFlow/destroyFlow on global registry are no-ops', () => {
+    class X extends FlowModel {}
+    X.registerFlow({ key: 'f', steps: {} });
+    const reg = X.globalFlowRegistry;
+
+    const flowForSave = reg.getFlow('f');
+    expect(() => reg.saveFlow(flowForSave!)).not.toThrow();
+    expect(() => reg.destroyFlow('f')).not.toThrow();
+  });
+
+  test("removeFlow warns and doesn't remove static flows", () => {
+    class X extends FlowModel {}
+    X.registerFlow({ key: 'f', steps: {} });
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      X.globalFlowRegistry.removeFlow('f');
+      expect(warnSpy).toHaveBeenCalled();
+      // Flow still present
+      expect(X.globalFlowRegistry.getFlow('f')).toBeDefined();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  test('child class inherits flows from parent registry', () => {
+    class ParentModel extends FlowModel {}
+    class ChildModel extends ParentModel {}
+
+    ParentModel.registerFlow({ key: 'inherited', title: 'From Parent', steps: {} });
+
+    // Child should see parent flow via global registry
+    const childReg = ChildModel.globalFlowRegistry;
+    const inherited = childReg.getFlow('inherited');
+    expect(inherited).toBeDefined();
+    expect(inherited?.title).toBe('From Parent');
+  });
+
+  test('child flow overrides parent flow with same key', () => {
+    class ParentModel extends FlowModel {}
+    class ChildModel extends ParentModel {}
+
+    ParentModel.registerFlow({ key: 'shared', title: 'Parent Title', steps: {} });
+    ChildModel.registerFlow({ key: 'shared', title: 'Child Title', steps: {} });
+
+    const childReg = ChildModel.globalFlowRegistry;
+    const flow = childReg.getFlow('shared');
+    expect(flow).toBeDefined();
+    expect(flow?.title).toBe('Child Title');
+  });
+
+  test('FlowModel instance merges instance and static flows with instance precedence', () => {
+    const engine = new FlowEngine();
+
+    class MyModel extends FlowModel {}
+    engine.registerModels({ MyModel });
+
+    // Static flows
+    MyModel.registerFlow({ key: 'static1', title: 'S1', steps: {} });
+    MyModel.registerFlow({ key: 'dup', title: 'Static DUP', steps: {} });
+
+    const model = engine.createModel({ use: 'MyModel' });
+
+    // Instance flows
+    model.flowRegistry.addFlow('inst1', { title: 'I1', steps: {} });
+    model.flowRegistry.addFlow('dup', { title: 'Instance DUP', steps: {} });
+
+    const all = model.getFlows();
+    // Contains both static and instance keys
+    expect(Array.from(all.keys()).sort()).toEqual(['dup', 'inst1', 'static1']);
+
+    // Instance takes precedence for duplicate key
+    expect(all.get('dup')?.title).toBe('Instance DUP');
+    expect(all.get('static1')?.title).toBe('S1');
+  });
+
+  test('dispatchEvent triggers both static and instance event flows', async () => {
+    const engine = new FlowEngine();
+    class MyModel extends FlowModel {}
+    engine.registerModels({ MyModel });
+
+    const staticHandler = vi.fn().mockResolvedValue('static-called');
+    const instanceHandler = vi.fn().mockResolvedValue('instance-called');
+
+    // Static event flow
+    MyModel.registerFlow({
+      key: 'staticEvent',
+      on: { eventName: 'click' },
+      steps: { s: { handler: staticHandler } },
+    });
+
+    const model = engine.createModel({ use: 'MyModel' });
+    // Instance event flow
+    model.flowRegistry.addFlow('instEvent', {
+      on: { eventName: 'click' },
+      steps: { i: { handler: instanceHandler } },
+    });
+
+    model.dispatchEvent('click', { foo: 'bar' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(staticHandler).toHaveBeenCalled();
+    expect(instanceHandler).toHaveBeenCalled();
+  });
+});