Issue #390: WIP

Signed-off-by: alexmerlin <[email protected]>

Author: alexmerlin

config/pipeline.php

@@ -8,6 +8,7 @@
 use Api\App\Middleware\ContentNegotiationMiddleware;
 use Api\App\Middleware\DeprecationMiddleware;
 use Api\App\Middleware\ResponseMiddleware;
+use Core\App\Middleware\ResourceProviderMiddleware;
 use Dot\ErrorHandler\ErrorHandlerInterface;
 use Dot\ResponseHeader\Middleware\ResponseHeaderMiddleware;
 use Mezzio\Application;
@@ -81,6 +82,7 @@
     // - etc.
 
     $app->pipe(ResponseMiddleware::class);
+    $app->pipe(ResourceProviderMiddleware::class);
 
     // Register the dispatch middleware in the middleware pipeline
     $app->pipe(DispatchMiddleware::class);

src/Admin/src/Handler/Admin/GetAdminResourceHandler.php

@@ -5,8 +5,9 @@
 namespace Api\Admin\Handler\Admin;
 
 use Api\Admin\Service\AdminServiceInterface;
-use Api\App\Exception\NotFoundException;
 use Api\App\Handler\AbstractHandler;
+use Core\Admin\Entity\Admin;
+use Core\App\Attribute\Resource;
 use Dot\DependencyInjection\Attribute\Inject;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
@@ -21,13 +22,12 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @throws NotFoundException
-     */
+    #[Resource(class: Admin::class)]
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
-        $admin = $this->adminService->findOneBy(['uuid' => $request->getAttribute('uuid')]);
-
-        return $this->createResponse($request, $admin);
+        return $this->createResponse(
+            $request,
+            $request->getAttribute(Resource::class)
+        );
     }
 }

src/App/src/Middleware/DeprecationMiddleware.php

@@ -7,20 +7,16 @@
 use Api\App\Attribute\MethodDeprecation;
 use Api\App\Attribute\ResourceDeprecation;
 use Api\App\Exception\DeprecationConflictException;
+use Api\App\Service\HandlerService;
 use Core\App\Message;
 use Dot\DependencyInjection\Attribute\Inject;
-use Dot\Router\Middleware\LazyLoadingMiddleware;
-use Laminas\Stratigility\MiddlewarePipe;
-use Mezzio\Middleware\LazyLoadingMiddleware as MezzioLazyLoadingMiddleware;
-use Mezzio\Router\RouteResult;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;
-use RuntimeException;
 
 use function array_column;
 use function array_filter;
@@ -57,19 +53,10 @@ public function process(
         ServerRequestInterface $request,
         RequestHandlerInterface $handler
     ): ResponseInterface {
-        $response    = $handler->handle($request);
-        $routeResult = $request->getAttribute(RouteResult::class);
-        if (! $routeResult instanceof RouteResult || $routeResult->isFailure()) {
-            return $response;
-        }
-
-        $matchedRoute = $routeResult->getMatchedRoute();
-        if (! $matchedRoute) {
-            return $response;
-        }
+        $response = $handler->handle($request);
 
-        $reflectionHandler = $this->getHandler($matchedRoute->getMiddleware());
-        if (empty($reflectionHandler)) {
+        $reflectionHandler = HandlerService::fromRequest($request);
+        if (! $reflectionHandler instanceof ReflectionClass) {
             return $response;
         }
 
@@ -136,38 +123,6 @@ private function getReflectionAttributes(ReflectionClass $reflectionObject): arr
         return $attributes;
     }
 
-    /**
-     * @throws ReflectionException
-     */
-    private function getHandler(MiddlewareInterface $routeMiddleware): ?ReflectionClass
-    {
-        $reflectionHandler = null;
-        if (
-            $routeMiddleware instanceof MezzioLazyLoadingMiddleware
-            || $routeMiddleware instanceof LazyLoadingMiddleware
-        ) {
-            /** @var class-string $routeMiddlewareName */
-            $routeMiddlewareName       = $routeMiddleware->middlewareName;
-            $reflectionMiddlewareClass = new ReflectionClass($routeMiddlewareName);
-            if ($reflectionMiddlewareClass->implementsInterface(RequestHandlerInterface::class)) {
-                $reflectionHandler = $reflectionMiddlewareClass;
-            }
-        } elseif ($routeMiddleware instanceof MiddlewarePipe) {
-            $reflectionClass    = new ReflectionClass($routeMiddleware);
-            $middlewarePipeline = $reflectionClass->getProperty('pipeline')->getValue($routeMiddleware);
-            for ($middlewarePipeline->rewind(); $middlewarePipeline->valid(); $middlewarePipeline->next()) {
-                $reflectionMiddlewareClass = new ReflectionClass($middlewarePipeline->current()->middlewareName);
-                if ($reflectionMiddlewareClass->implementsInterface(RequestHandlerInterface::class)) {
-                    $reflectionHandler = $reflectionMiddlewareClass;
-                }
-            }
-        } else {
-            throw new RuntimeException('Invalid route middleware provided.');
-        }
-
-        return $reflectionHandler;
-    }
-
     private function validateAttributes(array $attributes): void
     {
         $intersect = array_intersect(self::DEPRECATION_ATTRIBUTES, array_column($attributes, 'deprecationType'));

src/App/src/Service/HandlerService.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Api\App\Service;
+
+use Api\App\Exception\RuntimeException;
+use Laminas\Stratigility\MiddlewarePipe;
+use Mezzio\Middleware\LazyLoadingMiddleware as MezzioLazyLoadingMiddleware;
+use Mezzio\Router\Route;
+use Mezzio\Router\RouteResult;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use ReflectionClass;
+use ReflectionException;
+
+class HandlerService
+{
+    /**
+     * @throws ReflectionException
+     */
+    public static function fromRequest(ServerRequestInterface $request): ?ReflectionClass
+    {
+        $routeResult = $request->getAttribute(RouteResult::class);
+        if (! $routeResult instanceof RouteResult || $routeResult->isFailure()) {
+            return null;
+        }
+
+        $matchedRoute = $routeResult->getMatchedRoute();
+        if (! $matchedRoute instanceof Route) {
+            return null;
+        }
+
+        $routeMiddleware = $matchedRoute->getMiddleware();
+        if (
+            $routeMiddleware instanceof MezzioLazyLoadingMiddleware
+            || $routeMiddleware instanceof \Dot\Router\Middleware\LazyLoadingMiddleware
+        ) {
+            /** @var class-string $routeMiddlewareName */
+            $routeMiddlewareName       = $routeMiddleware->middlewareName;
+            $reflectionMiddlewareClass = new ReflectionClass($routeMiddlewareName);
+            if ($reflectionMiddlewareClass->implementsInterface(RequestHandlerInterface::class)) {
+                return $reflectionMiddlewareClass;
+            }
+        } elseif ($routeMiddleware instanceof MiddlewarePipe) {
+            $reflectionClass    = new ReflectionClass($routeMiddleware);
+            $middlewarePipeline = $reflectionClass->getProperty('pipeline')->getValue($routeMiddleware);
+            for ($middlewarePipeline->rewind(); $middlewarePipeline->valid(); $middlewarePipeline->next()) {
+                $reflectionMiddlewareClass = new ReflectionClass($middlewarePipeline->current()->middlewareName);
+                if ($reflectionMiddlewareClass->implementsInterface(RequestHandlerInterface::class)) {
+                    return $reflectionMiddlewareClass;
+                }
+            }
+        } else {
+            throw new RuntimeException('Invalid route middleware provided.');
+        }
+
+        return null;
+    }
+}

src/Core/src/App/src/Attribute/Resource.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Core\App\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD)]
+readonly class Resource implements ResourceInterface
+{
+    /** @param class-string $class */
+    public function __construct(
+        public string $class,
+        public string $identifier = 'uuid',
+        public string $placeholder = 'uuid',
+    ) {
+    }
+}

src/Core/src/App/src/Attribute/ResourceInterface.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Core\App\Attribute;
+
+interface ResourceInterface
+{
+}

src/Core/src/App/src/ConfigProvider.php

@@ -6,12 +6,14 @@
 
 use Api\App\Factory\EntityListenerResolverFactory;
 use Core\App\Entity\EntityListenerResolver;
+use Core\App\Middleware\ResourceProviderMiddleware;
 use Doctrine\ORM\EntityManager;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\Driver\AttributeDriver;
 use Doctrine\Persistence\Mapping\Driver\MappingDriverChain;
 use Dot\Cache\Adapter\ArrayAdapter;
 use Dot\Cache\Adapter\FilesystemAdapter;
+use Dot\DependencyInjection\Factory\AttributedServiceFactory;
 use Ramsey\Uuid\Doctrine\UuidBinaryOrderedTimeType;
 use Ramsey\Uuid\Doctrine\UuidBinaryType;
 use Ramsey\Uuid\Doctrine\UuidType;
@@ -36,6 +38,7 @@ public function getDependencies(): array
             'factories' => [
                 'doctrine.entity_manager.orm_default' => EntityManagerFactory::class,
                 EntityListenerResolver::class         => EntityListenerResolverFactory::class,
+                ResourceProviderMiddleware::class     => AttributedServiceFactory::class,
             ],
             'aliases'   => [
                 EntityManager::class          => 'doctrine.entity_manager.orm_default',

src/Core/src/App/src/Message.php

@@ -32,6 +32,7 @@ class Message
     public const RESET_PASSWORD_USED              = 'Password reset request for hash: \'%s\' is invalid (used).';
     public const RESET_PASSWORD_VALID             = 'Password reset request for hash: \'%s\' is valid.';
     public const RESOURCE_NOT_ALLOWED             = 'You are not allowed to access this resource.';
+    public const RESOURCE_NOT_FOUND               = '%s not found.';
     public const RESTRICTION_DEPRECATION          = 'Cannot use both `%s` and `%s` attributes on the same object.';
     public const RESTRICTION_IMAGE                = 'File must be an image (jpg, png).';
     public const RESTRICTION_ROLES                = 'User accounts must have at least one role.';

src/Core/src/App/src/Middleware/ResourceProviderMiddleware.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Core\App\Middleware;
+
+use Api\App\Exception\NotFoundException;
+use Api\App\Service\HandlerService;
+use Core\App\Attribute\Resource;
+use Core\App\Message;
+use Doctrine\ORM\EntityManagerInterface;
+use Dot\DependencyInjection\Attribute\Inject;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use ReflectionClass;
+use ReflectionException;
+
+use function array_pop;
+use function count;
+use function explode;
+use function sprintf;
+
+readonly class ResourceProviderMiddleware implements MiddlewareInterface
+{
+    #[Inject(EntityManagerInterface::class)]
+    public function __construct(
+        private EntityManagerInterface $entityManager,
+    ) {
+    }
+
+    /**
+     * @throws NotFoundException
+     * @throws ReflectionException
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $reflectionHandler = HandlerService::fromRequest($request);
+        if (! $reflectionHandler instanceof ReflectionClass) {
+            return $handler->handle($request);
+        }
+
+        $reflectionAttributes = $reflectionHandler->getMethod('handle')->getAttributes(Resource::class);
+        if (count($reflectionAttributes) === 0) {
+            return $handler->handle($request);
+        }
+
+        /** @var Resource $resource */
+        $resource = $reflectionAttributes[0]->newInstance();
+
+        $entity = $this->entityManager->getRepository($resource->class)->findOneBy([
+            $resource->identifier => $request->getAttribute($resource->placeholder),
+        ]);
+        if ($entity === null) {
+            $entity = explode('\\', $resource->class);
+            throw new NotFoundException(
+                sprintf(Message::RESOURCE_NOT_FOUND, array_pop($entity)),
+            );
+        }
+
+        return $handler->handle($request->withAttribute(Resource::class, $entity));
+    }
+}