feat: support explicit bindings for router

Author: albertcht

src/router/src/Middleware/SubstituteBindings.php

@@ -15,6 +15,7 @@
 use Hypervel\Router\Contracts\UrlRoutable;
 use Hypervel\Router\Exceptions\BackedEnumCaseNotFoundException;
 use Hypervel\Router\Exceptions\UrlRoutableNotFoundException;
+use Hypervel\Router\Router;
 use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
@@ -25,8 +26,15 @@
 
 class SubstituteBindings implements MiddlewareInterface
 {
-    public function __construct(protected ContainerInterface $container)
-    {
+    /**
+     * All of the resolved definitions by dispatched routes.
+     */
+    protected array $resolvedDefinitions = [];
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Router $router
+    ) {
     }
 
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
@@ -38,13 +46,11 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
             return $handler->handle($request);
         }
 
-        if (strpos($dispatched->handler->route, '{') === false) {
+        if (! $params = $dispatched->params) {
             return $handler->handle($request);
         }
 
         $definitions = $this->getDefinitions($dispatched->handler->callback);
-        $params = $dispatched->params;
-
         $dispatched->params = $this->substituteBindings($definitions, $params);
 
         return $handler->handle($request);
@@ -71,11 +77,14 @@ protected function getDefinitions(array|Closure|string $callback): array
      */
     protected function getClosureDefinitions(Closure $callback): array
     {
-        if (! $this->container->has(ClosureDefinitionCollectorInterface::class)) {
-            return [];
+        $signature = spl_object_hash($callback);
+        if ($definitions = $this->resolvedDefinitions[$signature] ?? null) {
+            return $definitions;
         }
 
-        return $this->container->get(ClosureDefinitionCollectorInterface::class)->getParameters($callback);
+        return $this->resolvedDefinitions[$signature] = $this->container->has(ClosureDefinitionCollectorInterface::class)
+            ? $this->container->get(ClosureDefinitionCollectorInterface::class)->getParameters($callback)
+            : [];
     }
 
     /**
@@ -86,7 +95,12 @@ protected function getMethodDefinitions(array $callback): array
         $controller = $callback[0];
         $action = $callback[1];
 
-        return $this->container->get(MethodDefinitionCollectorInterface::class)->getParameters($controller, $action);
+        $signature = "{$controller}::{$action}";
+        if ($definitions = $this->resolvedDefinitions[$signature] ?? null) {
+            return $definitions;
+        }
+
+        return $this->resolvedDefinitions[$signature] = $this->container->get(MethodDefinitionCollectorInterface::class)->getParameters($controller, $action);
     }
 
     /**
@@ -100,7 +114,10 @@ protected function substituteBindings(array $definitions, array $params): array
             if (! array_key_exists($name, $params)) {
                 continue;
             }
-
+            if ($binding = $this->router->getExplicitBinding($name)) {
+                $params[$name] = $binding($params[$name]);
+                continue;
+            }
             if ($binding = $this->resolveBinding($definition, $params, $name)) {
                 $params[$name] = $binding;
             }
@@ -113,7 +130,7 @@ protected function substituteBindings(array $definitions, array $params): array
      * @throws ModelNotFoundException
      * @throws BackedEnumCaseNotFoundException
      */
-    protected function resolveBinding(ReflectionType $definition, array $params, string $name)
+    protected function resolveBinding(ReflectionType $definition, array $params, string $name): mixed
     {
         $class = $definition->getName();
 
@@ -122,12 +139,17 @@ protected function resolveBinding(ReflectionType $definition, array $params, str
         }
 
         if (is_a($class, Model::class, true)) {
-            return $this->resolveModel($class, $params[$name]);
+            return $this->resolveModel(
+                $this->router->getModelBinding($name) ?: $class,
+                $params[$name]
+            );
         }
 
         if (is_a($class, BackedEnum::class, true)) {
             return $this->resolveBackedEnum($class, $params[$name]);
         }
+
+        return null;
     }
 
     /**

src/router/src/Router.php

@@ -6,7 +6,9 @@
 
 use Closure;
 use Hyperf\Context\ApplicationContext;
+use Hyperf\Database\Model\Model;
 use Hyperf\HttpServer\Router\DispatcherFactory;
+use Hyperf\HttpServer\Router\RouteCollector;
 use RuntimeException;
 
 /**
@@ -16,6 +18,20 @@ class Router
 {
     protected string $serverName = 'http';
 
+    /**
+     * Customized route parameters for model bindings.
+     *
+     * @var array<string, class-string>
+     */
+    protected array $modelBindings = [];
+
+    /**
+     * Customized route parameters for explicit bindings.
+     *
+     * @var array<string, Closure>
+     */
+    protected array $explicitBindings = [];
+
     public function __construct(protected DispatcherFactory $dispatcherFactory)
     {
     }
@@ -59,12 +75,40 @@ protected function registerRouteFile(string $routeFile): Closure
         return fn () => require $routeFile;
     }
 
-    public function getRouter()
+    public function getRouter(): RouteCollector
     {
         return $this->dispatcherFactory
             ->getRouter($this->serverName);
     }
 
+    public function model(string $param, string $modelClass): void
+    {
+        if (! class_exists($modelClass)) {
+            throw new RuntimeException("Model class `{$modelClass}` does not exist.");
+        }
+
+        if (! is_subclass_of($modelClass, Model::class)) {
+            throw new RuntimeException("Model class `{$modelClass}` must be a subclass of `Model`.");
+        }
+
+        $this->modelBindings[$param] = $modelClass;
+    }
+
+    public function bind(string $param, Closure $callback): void
+    {
+        $this->explicitBindings[$param] = $callback;
+    }
+
+    public function getModelBinding(string $param): ?string
+    {
+        return $this->modelBindings[$param] ?? null;
+    }
+
+    public function getExplicitBinding(string $param): ?Closure
+    {
+        return $this->explicitBindings[$param] ?? null;
+    }
+
     public static function __callStatic(string $name, array $arguments)
     {
         return ApplicationContext::getContainer()