Fix events not using correct type for dispatching

example/example.dart

@@ -149,29 +149,29 @@ class LoggingBehavior implements PipelineBehavior {
 
 class LoggingEventObserver implements EventObserver {
   @override
-  void onDispatch<TEvent extends DomainEvent>(
+  void onDispatch<TEvent>(
     TEvent event,
-    Set<EventHandler<TEvent>> handlers,
+    Set<EventHandler> handlers,
   ) {
     print(
       '[LoggingEventObserver] onDispatch "$event" with ${handlers.length} handlers',
     );
   }
 
   @override
-  void onError<TEvent extends DomainEvent>(
+  void onError<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
     Object error,
     StackTrace stackTrace,
   ) {
     print('[LoggingEventObserver] onError $event -> $handler ($error)');
   }
 
   @override
-  void onHandled<TEvent extends DomainEvent>(
+  void onHandled<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
   ) {
     print('[LoggingEventObserver] onHandled $event handled by $handler');
   }

lib/src/event/dispatch/concurrent_strategy.dart

@@ -1,5 +1,4 @@
 import 'package:dart_mediator/src/event/dispatch/dispatch_strategy.dart';
-import 'package:dart_mediator/src/event/event.dart';
 import 'package:dart_mediator/src/event/handler/event_handler.dart';
 import 'package:dart_mediator/src/event/observer/event_observer.dart';
 
@@ -12,7 +11,7 @@ class ConcurrentDispatchStrategy implements DispatchStrategy {
   const ConcurrentDispatchStrategy();
 
   @override
-  Future<void> execute<TEvent extends DomainEvent>(
+  Future<void> execute<TEvent>(
     Set<EventHandler<TEvent>> handlers,
     TEvent event,
     List<EventObserver> observers,

lib/src/event/dispatch/dispatch_strategy.dart

@@ -1,4 +1,3 @@
-import 'package:dart_mediator/src/event/event.dart';
 import 'package:dart_mediator/src/event/handler/event_handler.dart';
 import 'package:dart_mediator/src/event/dispatch/concurrent_strategy.dart';
 import 'package:dart_mediator/src/event/dispatch/sequential_strategy.dart';
@@ -18,7 +17,7 @@ abstract interface class DispatchStrategy {
 
   /// Executes the given strategy by applying the [event] to the given
   /// [handlers].
-  Future<void> execute<TEvent extends DomainEvent>(
+  Future<void> execute<TEvent>(
     Set<EventHandler<TEvent>> handlers,
     TEvent event,
     List<EventObserver> observers,

lib/src/event/dispatch/sequential_strategy.dart

@@ -1,5 +1,4 @@
 import 'package:dart_mediator/src/event/dispatch/dispatch_strategy.dart';
-import 'package:dart_mediator/src/event/event.dart';
 import 'package:dart_mediator/src/event/handler/event_handler.dart';
 import 'package:dart_mediator/src/event/observer/event_observer.dart';
 
@@ -14,7 +13,7 @@ class SequentialDispatchStrategy implements DispatchStrategy {
   const SequentialDispatchStrategy();
 
   @override
-  Future<void> execute<TEvent extends DomainEvent>(
+  Future<void> execute<TEvent>(
     Set<EventHandler<TEvent>> handlers,
     TEvent event,
     List<EventObserver> observers,

lib/src/event/event_manager.dart

@@ -57,7 +57,15 @@ class EventManager {
     TEvent event, [
     DispatchStrategy? dispatchStrategy,
   ]) async {
-    final handlers = _eventHandlerStore.getHandlersFor<TEvent>();
+    late final eventRuntimeType = event.runtimeType;
+
+    final handlers = {
+      // Add handlers for TEvent.
+      ..._eventHandlerStore.getHandlersFor(TEvent),
+      // If a base type was used, add handlers for the runtime type.
+      if (eventRuntimeType != TEvent)
+        ..._eventHandlerStore.getHandlersFor(eventRuntimeType)
+    };
 
     for (final observer in _observers) {
       observer.onDispatch(event, handlers);

lib/src/event/handler/event_handler_store.dart

@@ -7,23 +7,23 @@ class EventHandlerStore {
 
   /// Registers the [handler] to a given [TEvent].
   void register<TEvent>(EventHandler<TEvent> handler) {
-    final handlers = _getHandlersFor<TEvent>();
+    final handlers = _getHandlersFor(TEvent);
 
     assert(
       !handlers.contains(handler),
       'register<$TEvent> was called with an already registered handler',
     );
 
     // When the store is being modified, create a new copy.
-    _handlers[TEvent] = <EventHandler<TEvent>>{
+    _handlers[TEvent] = <EventHandler>{
       ...handlers,
       handler,
     };
   }
 
   /// Unregisters the given [handler].
   void unregister<TEvent>(EventHandler<TEvent> handler) {
-    final handlers = _getHandlersFor<TEvent>();
+    final handlers = _getHandlersFor(TEvent);
 
     assert(
       handlers.contains(handler),
@@ -36,18 +36,18 @@ class EventHandlerStore {
     _handlers[TEvent] = update;
   }
 
-  /// Returns all registered [EventHandler]'s for [TEvent].
-  Set<EventHandler<TEvent>> getHandlersFor<TEvent>() {
-    final handlers = _getHandlersFor<TEvent>();
+  /// Returns all registered [EventHandler]'s for [eventType].
+  Set<EventHandler> getHandlersFor(Type eventType) {
+    final handlers = _getHandlersFor(eventType);
 
     return UnmodifiableSetView(handlers);
   }
 
-  Set<EventHandler<TEvent>> _getHandlersFor<TEvent>() {
+  Set<EventHandler> _getHandlersFor(Type eventType) {
     final handlers = _handlers.putIfAbsent(
-      TEvent,
-      () => <EventHandler<TEvent>>{},
-    ) as Set<EventHandler<TEvent>>;
+      eventType,
+      () => <EventHandler>{},
+    );
 
     return handlers;
   }

lib/src/event/observer/event_observer.dart

@@ -7,22 +7,22 @@ abstract interface class EventObserver {
   /// When the [event] is dispatched.
   ///
   /// [handlers] will be executed based on the [DispatchStrategy].
-  void onDispatch<TEvent extends DomainEvent>(
+  void onDispatch<TEvent>(
     TEvent event,
-    Set<EventHandler<TEvent>> handlers,
+    Set<EventHandler> handlers,
   );
 
   /// When the [event] is handled by the [handler].
-  void onHandled<TEvent extends DomainEvent>(
+  void onHandled<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
   );
 
   /// When the [event] is failed by the [handler] the [error] contains the
   /// exception object.
-  void onError<TEvent extends DomainEvent>(
+  void onError<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
     Object error,
     StackTrace stackTrace,
   );

test/integration/choreography_test.dart

@@ -220,19 +220,19 @@ class InventoryAdjustedEventHandler
 
 class LoggingEventObserver implements EventObserver {
   @override
-  void onDispatch<TEvent extends DomainEvent>(
+  void onDispatch<TEvent>(
     TEvent event,
-    Set<EventHandler<TEvent>> handlers,
+    Set<EventHandler> handlers,
   ) {
     print(
       '$LoggingEventObserver: onDispatch $event with ${handlers.length} handlers',
     );
   }
 
   @override
-  void onError<TEvent extends DomainEvent>(
+  void onError<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
     Object error,
     StackTrace stackTrace,
   ) {
@@ -241,9 +241,9 @@ class LoggingEventObserver implements EventObserver {
   }
 
   @override
-  void onHandled<TEvent extends DomainEvent>(
+  void onHandled<TEvent>(
     TEvent event,
-    EventHandler<TEvent> handler,
+    EventHandler handler,
   ) {
     print('$LoggingEventObserver: onHandled $event -> ${handler.runtimeType}');
   }

test/integration/event_test.dart

@@ -147,10 +147,41 @@ void main() {
         expect(handler3, expected);
         expect(eventHandler.events, expected);
       });
+
+      test('it uses instance and compile event type to dispatch', () async {
+        late final bool concreteEventHandled;
+        late final bool baseEventHandled;
+
+        mediator.events
+            .on<BaseEvent>()
+            .subscribeFunction((e) => baseEventHandled = true);
+
+        mediator.events
+            .on<ConcreteEvent>()
+            .subscribeFunction((e) => concreteEventHandled = true);
+
+        await mediator.events.dispatchBaseEvent(const BaseEvent.concrete());
+
+        expect(
+          baseEventHandled,
+          isTrue,
+          reason: 'Compile type should be used to dispatch events',
+        );
+
+        expect(
+          concreteEventHandled,
+          isTrue,
+          reason: 'Instance type should be used to dispatch events',
+        );
+      });
     });
   });
 }
 
+extension _BaseEventExtension on EventManager {
+  Future<void> dispatchBaseEvent(BaseEvent event) => dispatch(event);
+}
+
 class _CollectingEventSubscriber implements EventHandler<DomainIntEvent> {
   final events = <int>[];
 

test/test_data.dart

@@ -202,3 +202,11 @@ class EventS implements DomainEvent {
   @override
   String toString() => 'EventS(s: $s)';
 }
+
+class BaseEvent implements DomainEvent {
+  const factory BaseEvent.concrete() = ConcreteEvent;
+}
+
+class ConcreteEvent implements BaseEvent {
+  const ConcreteEvent();
+}

test/unit/event/event_handler/event_handler_store_test.dart

@@ -2,6 +2,7 @@ import 'package:dart_mediator/src/event/handler/event_handler_store.dart';
 import 'package:test/test.dart';
 
 import '../../../mocks.dart';
+import '../../../test_data.dart';
 
 void main() {
   group('EventHandlerStore', () {
@@ -57,13 +58,20 @@ void main() {
 
     group('getHandlersFor{TEvent}', () {
       test('it returns the registered handlers', () {
-        final handler = MockEventHandler<int>();
+        final baseHandler = MockEventHandler<BaseEvent>();
+        final concreteHandler = MockEventHandler<ConcreteEvent>();
 
-        eventHandlerStore.register(handler);
+        eventHandlerStore.register(baseHandler);
+        eventHandlerStore.register(concreteHandler);
+
+        expect(
+          eventHandlerStore.getHandlersFor(BaseEvent),
+          {baseHandler},
+        );
 
         expect(
-          eventHandlerStore.getHandlersFor<int>(),
-          {handler},
+          eventHandlerStore.getHandlersFor(ConcreteEvent),
+          {concreteHandler},
         );
       });
     });

test/unit/event/event_manager_test.dart

@@ -1,4 +1,5 @@
 import 'package:dart_mediator/src/event/event_manager.dart';
+import 'package:dart_mediator/src/event/handler/event_handler.dart';
 import 'package:dart_mediator/src/event/subscription_builder/event_subscription_builder.dart';
 import 'package:mocktail/mocktail.dart';
 import 'package:test/test.dart';
@@ -42,13 +43,13 @@ void main() {
       const event = DomainIntEvent(123);
 
       test('it executes the dispatch strategy', () async {
-        final handlers = {MockEventHandler<DomainIntEvent>()};
+        final Set<EventHandler> handlers = {MockEventHandler<DomainIntEvent>()};
 
-        when(() => mockEventHandlerStore.getHandlersFor<DomainIntEvent>())
+        when(() => mockEventHandlerStore.getHandlersFor(DomainIntEvent))
             .thenReturn(handlers);
 
-        when(() => mockDispatchStrategy.execute<DomainIntEvent>(
-            any(), any(), any())).thenAnswer((_) => Future.value());
+        when(() => mockDispatchStrategy.execute(any(), any(), any()))
+            .thenAnswer((_) => Future.value());
 
         await eventManager.dispatch(event);
 
@@ -57,18 +58,47 @@ void main() {
       });
 
       test('it calls onDispatch', () async {
-        final handlers = {MockEventHandler<DomainIntEvent>()};
+        final Set<EventHandler> handlers = {MockEventHandler<DomainIntEvent>()};
 
-        when(() => mockEventHandlerStore.getHandlersFor<DomainIntEvent>())
+        when(() => mockEventHandlerStore.getHandlersFor(DomainIntEvent))
             .thenReturn(handlers);
 
-        when(() => mockDispatchStrategy.execute<DomainIntEvent>(
-            any(), any(), any())).thenAnswer((_) => Future.value());
+        when(() => mockDispatchStrategy.execute(any(), any(), any()))
+            .thenAnswer((_) => Future.value());
 
         await eventManager.dispatch(event);
 
         verify(() => mockEventObserver.onDispatch(event, handlers));
       });
+
+      test('it gets both runtime and compile time handlers', () async {
+        final Set<MockEventHandler> baseHandlers = {
+          MockEventHandler<BaseEvent>()
+        };
+
+        final Set<MockEventHandler> concreteHandlers = {
+          MockEventHandler<ConcreteEvent>()
+        };
+
+        final combined = {...baseHandlers, ...concreteHandlers};
+
+        when(() => mockEventHandlerStore.getHandlersFor(BaseEvent))
+            .thenReturn(baseHandlers);
+
+        when(() => mockEventHandlerStore.getHandlersFor(ConcreteEvent))
+            .thenReturn(concreteHandlers);
+
+        when(() => mockDispatchStrategy.execute(any(), any(), any()))
+            .thenAnswer((_) => Future.value());
+
+        const event = BaseEvent.concrete();
+
+        await eventManager.dispatch(event);
+
+        verify(() => mockEventObserver.onDispatch(event, combined));
+        verify(() =>
+            mockDispatchStrategy.execute(combined, event, [mockEventObserver]));
+      });
     });
   });
 }