feat: event bus improvements (#623)

Author: brendt

src/Tempest/EventBus/src/EventBusDiscovery.php

@@ -10,6 +10,7 @@
 use Tempest\Core\HandlesDiscoveryCache;
 use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\MethodReflector;
+use Tempest\Reflection\TypeReflector;
 use UnitEnum;
 
 final readonly class EventBusDiscovery implements Discovery
@@ -44,9 +45,10 @@ public function discover(ClassReflector $class): void
                     continue;
                 }
 
+                /** @var TypeReflector $type */
                 $type = $parameters[0]->getType();
 
-                if (! $type->isClass()) {
+                if (! $type->isClass() && ! $type->isInterface()) {
                     continue;
                 }
 

src/Tempest/EventBus/src/GenericEventBus.php

@@ -24,22 +24,44 @@ public function listen(string|object $event, Closure $handler): void
 
     public function dispatch(string|object $event): void
     {
-        $eventName = match(true) {
+
+        $eventHandlers = $this->resolveHandlers($event);
+
+        $dispatch = $this->applyMiddleware(function (string|object $event) use ($eventHandlers): void {
+            foreach ($eventHandlers as $eventHandler) {
+                $callable = $eventHandler->normalizeCallable($this->container);
+
+                $callable($event);
+            }
+        });
+
+        $dispatch($event);
+    }
+
+    /** @return \Tempest\EventBus\CallableEventHandler[] */
+    private function resolveHandlers(string|object $event): array
+    {
+        $eventName = match (true) {
             $event instanceof BackedEnum => $event->value,
             $event instanceof UnitEnum => $event->name,
             is_string($event) => $event,
             default => $event::class,
         };
 
-        /** @var \Tempest\EventBus\CallableEventHandler[] $eventHandlers */
-        $eventHandlers = $this->eventBusConfig->handlers[$eventName] ?? [];
+        $handlers = $this->eventBusConfig->handlers[$eventName] ?? [];
 
-        foreach ($eventHandlers as $eventHandler) {
-            $callable = $eventHandler->normalizeCallable($this->container);
-            $callable = $this->applyMiddleware($callable);
+        if (is_object($event)) {
+            $interfaces = class_implements($event);
 
-            $callable($event);
+            foreach ($interfaces as $interface) {
+                $handlers = [
+                    ...$handlers,
+                    ...($this->eventBusConfig->handlers[$interface] ?? []),
+                ];
+            }
         }
+
+        return $handlers;
     }
 
     private function applyMiddleware(Closure $handler): Closure
@@ -50,7 +72,7 @@ private function applyMiddleware(Closure $handler): Closure
             $handler = fn (string|object $event) => $this->container->invoke(
                 $middlewareClass,
                 event: $event,
-                next: $handler
+                next: $handler,
             );
         }
 

src/Tempest/EventBus/tests/EventBusTest.php

@@ -12,6 +12,9 @@
 use Tempest\EventBus\EventBusConfig;
 use Tempest\EventBus\EventHandler;
 use Tempest\EventBus\GenericEventBus;
+use Tempest\EventBus\Tests\Fixtures\EventInterface;
+use Tempest\EventBus\Tests\Fixtures\EventInterfaceHandler;
+use Tempest\EventBus\Tests\Fixtures\EventInterfaceImplementation;
 use Tempest\EventBus\Tests\Fixtures\ItHappened;
 use Tempest\EventBus\Tests\Fixtures\MyEventBusMiddleware;
 use Tempest\EventBus\Tests\Fixtures\MyEventHandler;
@@ -46,12 +49,40 @@ public function test_class_based_handlers(): void
         $eventBus = new GenericEventBus($container, $config);
 
         MyEventHandler::$itHappened = false;
-        MyEventBusMiddleware::$hit = false;
+        MyEventBusMiddleware::$hits = 0;
 
         $eventBus->dispatch(new ItHappened());
 
         $this->assertTrue(MyEventHandler::$itHappened);
-        $this->assertTrue(MyEventBusMiddleware::$hit);
+        $this->assertSame(1, MyEventBusMiddleware::$hits);
+    }
+
+    public function test_middleware_is_only_triggered_once_per_event_dispatch(): void
+    {
+        $container = new GenericContainer();
+
+        $handler = new EventHandler();
+        $handler->setHandler(new MethodReflector(new ReflectionMethod(MyEventHandler::class, 'handleItHappened')));
+
+        $config = new EventBusConfig(
+            handlers: [
+                ItHappened::class => [
+                    new CallableEventHandler(ItHappened::class, $handler),
+                    new CallableEventHandler(ItHappened::class, $handler),
+                ],
+            ],
+            middleware: [
+                MyEventBusMiddleware::class,
+            ]
+        );
+
+        $eventBus = new GenericEventBus($container, $config);
+
+        MyEventBusMiddleware::$hits = 0;
+
+        $eventBus->dispatch(new ItHappened());
+
+        $this->assertSame(1, MyEventBusMiddleware::$hits);
     }
 
     public function test_closure_based_handlers(): void
@@ -76,12 +107,12 @@ public function test_closure_based_handlers(): void
 
         $eventBus = new GenericEventBus($container, $config);
 
-        MyEventBusMiddleware::$hit = false;
+        MyEventBusMiddleware::$hits = 0;
 
         $eventBus->dispatch(new ItHappened());
 
         $this->assertSame('bar', $called);
-        $this->assertTrue(MyEventBusMiddleware::$hit);
+        $this->assertSame(1, MyEventBusMiddleware::$hits);
     }
 
     public function test_closure_based_handlers_using_listen_method(): void
@@ -117,4 +148,28 @@ public function test_closure_based_handlers_using_function(): void
 
         $this->assertTrue($hasHappened);
     }
+
+    public function test_interface_handlers(): void
+    {
+        $container = new GenericContainer();
+
+        $handler = new EventHandler();
+        $handler->setHandler(new MethodReflector(new ReflectionMethod(EventInterfaceHandler::class, 'handleItHappened')));
+
+        $config = new EventBusConfig(
+            handlers: [
+                EventInterface::class => [
+                    new CallableEventHandler(EventInterface::class, $handler),
+                ],
+            ]
+        );
+
+        $eventBus = new GenericEventBus($container, $config);
+
+        EventInterfaceHandler::$itHappened = false;
+
+        $eventBus->dispatch(new EventInterfaceImplementation());
+
+        $this->assertTrue(EventInterfaceHandler::$itHappened);
+    }
 }

src/Tempest/EventBus/tests/Fixtures/EventInterface.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\EventBus\Tests\Fixtures;
+
+interface EventInterface
+{
+}

src/Tempest/EventBus/tests/Fixtures/EventInterfaceHandler.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\EventBus\Tests\Fixtures;
+
+use Tempest\EventBus\EventHandler;
+
+final class EventInterfaceHandler
+{
+    public static bool $itHappened = false;
+
+    #[EventHandler]
+    public function handleItHappened(EventInterface $event): void
+    {
+        self::$itHappened = true;
+    }
+}

src/Tempest/EventBus/tests/Fixtures/EventInterfaceImplementation.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\EventBus\Tests\Fixtures;
+
+final readonly class EventInterfaceImplementation implements EventInterface
+{
+}

src/Tempest/EventBus/tests/Fixtures/MyEventBusMiddleware.php

@@ -8,11 +8,11 @@
 
 final class MyEventBusMiddleware implements EventBusMiddleware
 {
-    public static bool $hit = false;
+    public static int $hits = 0;
 
     public function __invoke(object $event, callable $next): void
     {
-        self::$hit = true;
+        self::$hits += 1;
 
         $next($event);
     }

src/Tempest/EventBus/tests/Fixtures/MyInterfaceEventHandler.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\EventBus\Tests\Fixtures;
+
+use Tempest\EventBus\EventHandler;
+
+final class MyInterfaceEventHandler
+{
+    public static bool $itHappened = false;
+
+    #[EventHandler]
+    public function handleItHappened(ItHappened $event): void
+    {
+        self::$itHappened = true;
+    }
+}

src/Tempest/Reflection/src/TypeReflector.php

@@ -144,6 +144,11 @@ public function isClass(): bool
         return class_exists($this->cleanDefinition);
     }
 
+    public function isInterface(): bool
+    {
+        return interface_exists($this->cleanDefinition);
+    }
+
     public function isIterable(): bool
     {
         return in_array($this->cleanDefinition, [

tests/Fixtures/Events/EventInterface.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Tempest\Fixtures\Events;
+
+interface EventInterface
+{
+}