Migrating ParameterHandler to a middleware system

Currently the ParmeterHandlerInterface only allows for a handler to handle or not handle a parameter.
There is no way a ParameterHandler can "wrap" othe parameter handlers. So there is no easy way to write a ParameterHandler that does validation upon the result of other parameter handlers.

This commit moves ParameterMapperInterface to a system of ParameterMiddlewareInterface where parameter middlewares are chained.
We therefore get all the benefits of middlewares when handling parameters.

Author: moufmouf

src/FieldsBuilder.php

@@ -17,8 +17,8 @@
 use TheCodingMachine\GraphQLite\Annotations\SourceFieldInterface;
 use TheCodingMachine\GraphQLite\Mappers\CannotMapTypeException;
 use TheCodingMachine\GraphQLite\Mappers\CannotMapTypeExceptionInterface;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\ParameterMapperInterface;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\TypeMapper;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\ParameterMiddlewareInterface;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\TypeHandler;
 use TheCodingMachine\GraphQLite\Mappers\RecursiveTypeMapperInterface;
 use TheCodingMachine\GraphQLite\Mappers\Root\RootTypeMapperInterface;
 use TheCodingMachine\GraphQLite\Middlewares\FieldHandlerInterface;
@@ -49,9 +49,9 @@ class FieldsBuilder
     private $typeResolver;
     /** @var NamingStrategyInterface */
     private $namingStrategy;
-    /** @var TypeMapper */
+    /** @var TypeHandler */
     private $typeMapper;
-    /** @var ParameterMapperInterface */
+    /** @var ParameterMiddlewareInterface */
     private $parameterMapper;
     /** @var FieldMiddlewareInterface */
     private $fieldMiddleware;
@@ -64,15 +64,15 @@ public function __construct(
         CachedDocBlockFactory $cachedDocBlockFactory,
         NamingStrategyInterface $namingStrategy,
         RootTypeMapperInterface $rootTypeMapper,
-        ParameterMapperInterface $parameterMapper,
+        ParameterMiddlewareInterface $parameterMapper,
         FieldMiddlewareInterface $fieldMiddleware
     ) {
         $this->annotationReader      = $annotationReader;
         $this->recursiveTypeMapper   = $typeMapper;
         $this->typeResolver          = $typeResolver;
         $this->cachedDocBlockFactory = $cachedDocBlockFactory;
         $this->namingStrategy        = $namingStrategy;
-        $this->typeMapper            = new TypeMapper($typeMapper, $argumentResolver, $rootTypeMapper, $typeResolver);
+        $this->typeMapper            = new TypeHandler($typeMapper, $argumentResolver, $rootTypeMapper, $typeResolver);
         $this->parameterMapper       = $parameterMapper;
         $this->fieldMiddleware = $fieldMiddleware;
     }
@@ -480,11 +480,8 @@ private function mapParameters(array $refParameters, DocBlock $docBlock): array
         foreach ($refParameters as $parameter) {
             $parameterAnnotations = $this->annotationReader->getParameterAnnotations($parameter);
 
-            $parameterObj = $this->parameterMapper->mapParameter($parameter, $docBlock, $docBlockTypes[$parameter->getName()] ?? null, $parameterAnnotations);
+            $parameterObj = $this->parameterMapper->mapParameter($parameter, $docBlock, $docBlockTypes[$parameter->getName()] ?? null, $parameterAnnotations, $this->typeMapper);
 
-            if ($parameterObj === null) {
-                $parameterObj = $this->typeMapper->mapParameter($parameter, $docBlock, $docBlockTypes[$parameter->getName()] ?? null, $parameterAnnotations);
-            }
             $args[$parameter->getName()] = $parameterObj;
         }
 

src/Mappers/Parameters/CompositeParameterMapper.php

@@ -16,7 +16,7 @@
 /**
  * Maps parameters with the \@Autowire annotation to container entry based on the FQCN or the passed identifier.
  */
-class ContainerParameterMapper implements ParameterMapperInterface
+class ContainerParameterHandler implements ParameterMiddlewareInterface
 {
     /** @var ContainerInterface */
     private $container;
@@ -26,15 +26,15 @@ public function __construct(ContainerInterface $container)
         $this->container = $container;
     }
 
-    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations): ?ParameterInterface
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $next): ParameterInterface
     {
         /**
          * @var Autowire|null $autowire
          */
         $autowire = $parameterAnnotations->getAnnotationByType(Autowire::class);
 
         if ($autowire === null) {
-            return null;
+            return $next->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations);
         }
 
         $id = $autowire->getIdentifier();

src/Mappers/Parameters/ContainerParameterMapper.php renamed to src/Mappers/Parameters/ContainerParameterHandler.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Mappers\Parameters;
+
+use phpDocumentor\Reflection\DocBlock;
+use phpDocumentor\Reflection\Type;
+use ReflectionParameter;
+use SplQueue;
+use TheCodingMachine\GraphQLite\Annotations\ParameterAnnotations;
+use TheCodingMachine\GraphQLite\Parameters\ParameterInterface;
+
+/**
+ * Iterate a queue of middlewares and execute them.
+ */
+final class Next implements ParameterHandlerInterface
+{
+    /** @var ParameterHandlerInterface */
+    private $fallbackHandler;
+
+    /** @var SplQueue */
+    private $queue;
+
+    /**
+     * Clones the queue provided to allow re-use.
+     *
+     * @param ParameterHandlerInterface $fallbackHandler Fallback handler to
+     *     invoke when the queue is exhausted.
+     */
+    public function __construct(SplQueue $queue, ParameterHandlerInterface $fallbackHandler)
+    {
+        $this->queue           = clone $queue;
+        $this->fallbackHandler = $fallbackHandler;
+    }
+
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations): ParameterInterface
+    {
+        if ($this->queue->isEmpty()) {
+            return $this->fallbackHandler->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations);
+        }
+
+        /**
+         * @var ParameterMiddlewareInterface $middleware
+         */
+        $middleware = $this->queue->dequeue();
+
+        return $middleware->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations, $this);
+    }
+}

src/Mappers/Parameters/Next.php

@@ -10,7 +10,7 @@
 use TheCodingMachine\GraphQLite\Annotations\ParameterAnnotations;
 use TheCodingMachine\GraphQLite\Parameters\ParameterInterface;
 
-interface ParameterMapperInterface
+interface ParameterHandlerInterface
 {
-    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations): ?ParameterInterface;
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations): ParameterInterface;
 }

src/Mappers/Parameters/ParameterMapperInterface.php renamed to src/Mappers/Parameters/ParameterHandlerInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Mappers\Parameters;
+
+use phpDocumentor\Reflection\DocBlock;
+use phpDocumentor\Reflection\Type;
+use ReflectionParameter;
+use TheCodingMachine\GraphQLite\Annotations\ParameterAnnotations;
+use TheCodingMachine\GraphQLite\Parameters\ParameterInterface;
+
+/**
+ * Processes a parameter for a given query/mutation/field/factory.
+ */
+interface ParameterMiddlewareInterface
+{
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $next): ParameterInterface;
+}

src/Mappers/Parameters/ParameterMiddlewareInterface.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Mappers\Parameters;
+
+use phpDocumentor\Reflection\DocBlock;
+use phpDocumentor\Reflection\Type;
+use ReflectionParameter;
+use SplQueue;
+use TheCodingMachine\GraphQLite\Annotations\ParameterAnnotations;
+use TheCodingMachine\GraphQLite\Parameters\ParameterInterface;
+
+final class ParameterMiddlewarePipe implements ParameterMiddlewareInterface
+{
+    /** @var SplQueue<ParameterMiddlewareInterface> */
+    private $pipeline;
+
+    /**
+     * Initializes the queue.
+     */
+    public function __construct()
+    {
+        $this->pipeline = new SplQueue();
+    }
+
+    /**
+     * PSR-15 middleware invocation.
+     *
+     * Executes the internal pipeline, passing $handler as the "final
+     * handler" in cases when the pipeline exhausts itself.
+     */
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $parameterMapper): ParameterInterface
+    {
+        return (new Next($this->pipeline, $parameterMapper))->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations);
+    }
+
+    /**
+     * Attach middleware to the pipeline.
+     */
+    public function pipe(ParameterMiddlewareInterface $middleware): void
+    {
+        $this->pipeline->enqueue($middleware);
+    }
+}

src/Mappers/Parameters/ParameterMiddlewarePipe.php

@@ -12,15 +12,15 @@
 use TheCodingMachine\GraphQLite\Parameters\ParameterInterface;
 use TheCodingMachine\GraphQLite\Parameters\ResolveInfoParameter;
 
-class ResolveInfoParameterMapper implements ParameterMapperInterface
+class ResolveInfoParameterHandler implements ParameterMiddlewareInterface
 {
-    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations): ?ParameterInterface
+    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $parameterMapper): ParameterInterface
     {
         $type = $parameter->getType();
         if ($type!== null && $type->getName() === ResolveInfo::class) {
             return new ResolveInfoParameter();
         }
 
-        return null;
+        return $parameterMapper->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations);
     }
 }

src/Mappers/Parameters/ResolveInfoParameterMapper.php renamed to src/Mappers/Parameters/ResolveInfoParameterHandler.php

@@ -48,7 +48,7 @@
 use function count;
 use function iterator_to_array;
 
-class TypeMapper implements ParameterMapperInterface
+class TypeHandler implements ParameterHandlerInterface
 {
     /** @var PhpDocumentorTypeResolver */
     private $phpDocumentorTypeResolver;

src/Mappers/Parameters/TypeMapper.php renamed to src/Mappers/Parameters/TypeHandler.php

@@ -7,7 +7,7 @@
 use GraphQL\Type\Definition\ResolveInfo;
 
 /**
- * Instances of ParameterInterface represent a single PHP parameter in a Query/Mutation/Field.
+ * Instances of ParameterInterface represent a single PHP parameter in a Query/Mutation/Field/Factory.
  */
 interface ParameterInterface
 {

src/Parameters/ParameterInterface.php

@@ -18,10 +18,10 @@
 use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
 use TheCodingMachine\GraphQLite\Mappers\CompositeTypeMapper;
 use TheCodingMachine\GraphQLite\Mappers\GlobTypeMapper;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\CompositeParameterMapper;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\ContainerParameterMapper;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\ParameterMapperInterface;
-use TheCodingMachine\GraphQLite\Mappers\Parameters\ResolveInfoParameterMapper;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\ContainerParameterHandler;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\ParameterMiddlewareInterface;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\ParameterMiddlewarePipe;
+use TheCodingMachine\GraphQLite\Mappers\Parameters\ResolveInfoParameterHandler;
 use TheCodingMachine\GraphQLite\Mappers\PorpaginasTypeMapper;
 use TheCodingMachine\GraphQLite\Mappers\RecursiveTypeMapper;
 use TheCodingMachine\GraphQLite\Mappers\Root\BaseTypeMapper;
@@ -69,7 +69,7 @@ class SchemaFactory
     private $typeMappers = [];
     /** @var TypeMapperFactoryInterface[] */
     private $typeMapperFactories = [];
-    /** @var ParameterMapperInterface[] */
+    /** @var ParameterMiddlewareInterface[] */
     private $parameterMappers = [];
     /** @var Reader */
     private $doctrineAnnotationReader;
@@ -171,7 +171,7 @@ public function addTypeMapperFactory(TypeMapperFactoryInterface $typeMapperFacto
     /**
      * Registers a parameter mapper.
      */
-    public function addParameterMapper(ParameterMapperInterface $parameterMapper): self
+    public function addParameterMapper(ParameterMiddlewareInterface $parameterMapper): self
     {
         $this->parameterMappers[] = $parameterMapper;
 
@@ -322,10 +322,12 @@ public function createSchema(): Schema
 
         $argumentResolver = new ArgumentResolver();
 
-        $parameterMappers         = $this->parameterMappers;
-        $parameterMappers[]       = new ResolveInfoParameterMapper();
-        $parameterMappers[]       = new ContainerParameterMapper($this->container);
-        $compositeParameterMapper = new CompositeParameterMapper($parameterMappers);
+        $parameterMiddlewarePipe = new ParameterMiddlewarePipe();
+        foreach ($this->parameterMappers as $parameterMapper) {
+            $parameterMiddlewarePipe->pipe($parameterMapper);
+        }
+        $parameterMiddlewarePipe->pipe(new ResolveInfoParameterHandler());
+        $parameterMiddlewarePipe->pipe(new ContainerParameterHandler($this->container));
 
         $fieldsBuilder = new FieldsBuilder(
             $annotationReader,
@@ -335,7 +337,7 @@ public function createSchema(): Schema
             $cachedDocBlockFactory,
             $namingStrategy,
             $compositeRootTypeMapper,
-            $compositeParameterMapper,
+            $parameterMiddlewarePipe,
             $fieldMiddlewarePipe
         );