Merge branch 'main' into map-upload-files-into-request-properties

Author: yassiNebeL

src/Tempest/CommandBus/src/CommandBusConfig.php

@@ -17,8 +17,15 @@ public function __construct(
     ) {
     }
 
+    /**
+     * @throws CommandHandlerAlreadyExists
+     */
     public function addHandler(CommandHandler $commandHandler, string $commandName, MethodReflector $handler): self
     {
+        if (array_key_exists($commandName, $this->handlers)) {
+            throw new CommandHandlerAlreadyExists($commandName, new: $handler, existing: $this->handlers[$commandName]->handler);
+        }
+
         $this->handlers[$commandName] = $commandHandler
             ->setCommandName($commandName)
             ->setHandler($handler);

src/Tempest/CommandBus/src/CommandHandlerAlreadyExists.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\CommandBus;
+
+use Exception;
+use Tempest\Reflection\MethodReflector;
+
+final class CommandHandlerAlreadyExists extends Exception
+{
+    public function __construct(string $commandName, MethodReflector $new, MethodReflector $existing)
+    {
+        parent::__construct("Cannot add handler {$new->getShortName()}, {$existing->getShortName()} already handles {$commandName}.");
+    }
+}

src/Tempest/CommandBus/tests/Fixtures/CreateUserCommandHandler.php

@@ -18,4 +18,10 @@ public function __invoke(CreateUserCommand $command): void
         $this->firstName = $command->firstName;
         $this->lastName = $command->lastName;
     }
+
+    #[CommandHandler]
+    public function double(CreateUserCommand $command): void
+    {
+        // throws a CommandHandlerAlreadyExists exception since the command is already being handled by the __invoke method
+    }
 }

src/Tempest/CommandBus/tests/GenericCommandBusTest.php

@@ -8,6 +8,7 @@
 use Tempest\CommandBus\CommandBus;
 use Tempest\CommandBus\CommandBusConfig;
 use Tempest\CommandBus\CommandHandler;
+use Tempest\CommandBus\CommandHandlerAlreadyExists;
 use Tempest\CommandBus\CommandHandlerNotFound;
 use Tempest\CommandBus\GenericCommandBus;
 use Tempest\CommandBus\Tests\Fixtures\CreateUserCommand;
@@ -21,6 +22,8 @@
  */
 final class GenericCommandBusTest extends TestCase
 {
+    private CommandBusConfig $config;
+
     private CommandBus $commandBus;
 
     public function test_getting_command_handler_that_exists(): void
@@ -44,26 +47,41 @@ public function test_exception_is_thrown_when_command_handler_doesnt_exist(): vo
         $this->commandBus->dispatch($command);
     }
 
+    public function test_exception_is_thrown_when_command_handler_already_exist(): void
+    {
+        $createUserCommandHandlerClass = new ClassReflector(CreateUserCommandHandler::class);
+        $createUserCommandHandlerMethod = $createUserCommandHandlerClass->getMethod('__invoke');
+        $createUserCommandHandler = $createUserCommandHandlerMethod->getAttribute(CommandHandler::class);
+
+        $this->expectException(CommandHandlerAlreadyExists::class);
+
+        $this->config->addHandler(
+            commandHandler: $createUserCommandHandler,
+            commandName: CreateUserCommand::class,
+            handler: $createUserCommandHandlerClass->getMethod('double'),
+        );
+    }
+
     protected function setUp(): void
     {
         parent::setUp();
 
         // TODO: I'd like to make this easier to setup.
-        $config = new CommandBusConfig();
+        $this->config = new CommandBusConfig();
 
         $createUserCommandHandlerClass = new ClassReflector(CreateUserCommandHandler::class);
         $createUserCommandHandlerMethod = $createUserCommandHandlerClass->getMethod('__invoke');
         $createUserCommandHandler = $createUserCommandHandlerMethod->getAttribute(CommandHandler::class);
 
-        $config->addHandler(
+        $this->config->addHandler(
             commandHandler: $createUserCommandHandler,
             commandName: CreateUserCommand::class,
-            handler: $createUserCommandHandlerMethod
+            handler: $createUserCommandHandlerMethod,
         );
 
         $this->commandBus = new GenericCommandBus(
             container: new GenericContainer(),
-            commandBusConfig: $config
+            commandBusConfig: $this->config,
         );
     }
 }

src/Tempest/Http/src/Commands/ServeCommand.php

@@ -14,6 +14,8 @@
     )]
     public function __invoke(string $host = 'localhost', int $port = 8000, string $publicDir = 'public/'): void
     {
-        passthru("php -S {$host}:{$port} -t {$publicDir}");
+        putenv("TEMPEST_PUBLIC_DIR={$publicDir}");
+        $routerFile = __DIR__ . '/router.php';
+        passthru("php -S {$host}:{$port} -t {$publicDir} {$routerFile}");
     }
 }

src/Tempest/Http/src/Commands/router.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+$publicPath = getcwd() . '/' . rtrim($_ENV['TEMPEST_PUBLIC_DIR'], '/');
+
+if (file_exists($publicPath . $_SERVER['REQUEST_URI'])) {
+    return false;
+}
+
+require_once $publicPath . '/index.php';

src/Tempest/Http/src/Routing/Construction/RouteTreeNode.php

@@ -17,7 +17,7 @@ final class RouteTreeNode
     /** @var array<string, RouteTreeNode> */
     private array $dynamicPaths = [];
 
-    private ?MarkedRoute $leaf = null;
+    private ?MarkedRoute $targetRoute = null;
 
     private function __construct(
         public readonly RouteTreeNodeType $type,
@@ -40,34 +40,26 @@ public static function createStaticRouteNode(string $name): self
         return new self(RouteTreeNodeType::Static, $name);
     }
 
-    public function addPath(array $pathSegments, MarkedRoute $markedRoute): void
+    public function findOrCreateNodeForSegment(string $routeSegment): self
     {
-        // If path segments is empty this node should target to given marked route
-        if ($pathSegments === []) {
-            if ($this->leaf !== null) {
-                throw new DuplicateRouteException($markedRoute->route);
-            }
-
-            $this->leaf = $markedRoute;
+        // Translates a path segment like {id} into it's matching regex. Static segments remain the same
+        $regexRouteSegment = self::convertDynamicSegmentToRegex($routeSegment);
 
-            return;
+        // Returns a static or dynamic child node depending on the segment is dynamic or static
+        if ($routeSegment === $regexRouteSegment) {
+            return $this->staticPaths[$regexRouteSegment] ??= self::createStaticRouteNode($routeSegment);
         }
 
-        // Removes the first element of the pathSegments and use it to determin the next routing node
-        $currentPathSegment = array_shift($pathSegments);
-
-        // Translates a path segment like {id} into it's matching regex. Static segments remain the same
-        $regexPathSegment = self::convertDynamicSegmentToRegex($currentPathSegment);
+        return $this->dynamicPaths[$regexRouteSegment] ??= self::createDynamicRouteNode($regexRouteSegment);
+    }
 
-        // Find or create the next node to recurse into
-        if ($currentPathSegment !== $regexPathSegment) {
-            $node = $this->dynamicPaths[$regexPathSegment] ??= self::createDynamicRouteNode($regexPathSegment);
-        } else {
-            $node = $this->staticPaths[$regexPathSegment] ??= self::createStaticRouteNode($currentPathSegment);
+    public function setTargetRoute(MarkedRoute $markedRoute): void
+    {
+        if ($this->targetRoute !== null) {
+            throw new DuplicateRouteException($markedRoute->route);
         }
 
-        // Recurse into the newly created node to add the remainder of the path segments
-        $node->addPath($pathSegments, $markedRoute);
+        $this->targetRoute = $markedRoute;
     }
 
     private static function convertDynamicSegmentToRegex(string $uriPart): string
@@ -107,14 +99,14 @@ public function toRegex(): string
             // Add a leaf alteration with an optional slash and end of line match `$`.
             // The `(*MARK:x)` is a marker which when this regex is matched will cause the matches array to contain
             // a key `"MARK"` with value `"x"`, it is used to track which route has been matched
-            if ($this->leaf !== null) {
-                $regexp .= '|\/?$(*' . MarkedRoute::REGEX_MARK_TOKEN . ':' . $this->leaf->mark . ')';
+            if ($this->targetRoute !== null) {
+                $regexp .= '|\/?$(*' . MarkedRoute::REGEX_MARK_TOKEN . ':' . $this->targetRoute->mark . ')';
             }
 
             $regexp .= ")";
-        } elseif ($this->leaf !== null) {
+        } elseif ($this->targetRoute !== null) {
             // Add a singular leaf regex without alteration
-            $regexp .= '\/?$(*' . MarkedRoute::REGEX_MARK_TOKEN . ':' . $this->leaf->mark . ')';
+            $regexp .= '\/?$(*' . MarkedRoute::REGEX_MARK_TOKEN . ':' . $this->targetRoute->mark . ')';
         }
 
         return $regexp;

src/Tempest/Http/src/Routing/Construction/RoutingTree.php

@@ -22,10 +22,14 @@ public function add(MarkedRoute $markedRoute): void
         $method = $markedRoute->route->method;
 
         // Find the root tree node based on HTTP method
-        $root = $this->roots[$method->value] ??= RouteTreeNode::createRootRoute();
+        $node = $this->roots[$method->value] ??= RouteTreeNode::createRootRoute();
 
-        // Add path to tree using recursion
-        $root->addPath($markedRoute->route->split(), $markedRoute);
+        // Traverse the tree and find the node for each route segment
+        foreach ($markedRoute->route->split() as $routeSegment) {
+            $node = $node->findOrCreateNodeForSegment($routeSegment);
+        }
+
+        $node->setTargetRoute($markedRoute);
     }
 
     /** @return array<string, string> */