Merge pull request #18 from sunrise-php/release/v1.6.0

v1.6.0

.travis.yml

@@ -8,6 +8,7 @@ matrix:
   fast_finish: true
 
 before_install:
+  - travis_retry yes '' | pecl install -f apcu
   - travis_retry composer self-update
 
 install:

composer.json

@@ -22,6 +22,7 @@
     "require": {
         "php": "^7.1",
         "doctrine/annotations": "^1.6",
+        "doctrine/cache": "^1.6",
         "sunrise/http-router": "^2.4"
     },
     "require-dev": {

src/AbstractAnnotation.php

@@ -14,7 +14,7 @@
 /**
  * Import classes
  */
-use Doctrine\Common\Annotations\SimpleAnnotationReader;
+use Doctrine\Common\Annotations\Reader as AnnotationReader;
 
 /**
  * Import functions
@@ -31,11 +31,11 @@ abstract class AbstractAnnotation extends AbstractObject
     /**
      * Recursively collects all annotations referenced by this object or its children
      *
-     * @param SimpleAnnotationReader $annotationReader
+     * @param AnnotationReader $annotationReader
      *
      * @return ComponentObjectInterface[]
      */
-    public function getReferencedObjects(SimpleAnnotationReader $annotationReader) : array
+    public function getReferencedObjects(AnnotationReader $annotationReader) : array
     {
         $fields = $this->getFields();
         $objects = [];

src/AbstractAnnotationReference.php

@@ -14,7 +14,7 @@
 /**
  * Import classes
  */
-use Doctrine\Common\Annotations\SimpleAnnotationReader;
+use Doctrine\Common\Annotations\Reader as AnnotationReader;
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionProperty;
@@ -94,13 +94,13 @@ abstract public function getAnnotationName() : string;
     /**
      * Tries to find a referenced object that implements the `ComponentObjectInterface` interface
      *
-     * @param SimpleAnnotationReader $annotationReader
+     * @param AnnotationReader $annotationReader
      *
      * @return ComponentObjectInterface
      *
      * @throws InvalidReferenceException
      */
-    public function getAnnotation(SimpleAnnotationReader $annotationReader) : ComponentObjectInterface
+    public function getAnnotation(AnnotationReader $annotationReader) : ComponentObjectInterface
     {
         $key = hash(
             'md5',
@@ -128,17 +128,17 @@ public function getAnnotation(SimpleAnnotationReader $annotationReader) : Compon
     }
 
     /**
-     * Proxy to `SimpleAnnotationReader::getMethodAnnotation()` with validation
+     * Proxy to `AnnotationReader::getMethodAnnotation()` with validation
      *
-     * @param SimpleAnnotationReader $annotationReader
+     * @param AnnotationReader $annotationReader
      *
      * @return ComponentObjectInterface
      *
      * @throws InvalidReferenceException
      *
-     * @see SimpleAnnotationReader::getMethodAnnotation()
+     * @see AnnotationReader::getMethodAnnotation()
      */
-    private function getMethodAnnotation(SimpleAnnotationReader $annotationReader) : ComponentObjectInterface
+    private function getMethodAnnotation(AnnotationReader $annotationReader) : ComponentObjectInterface
     {
         if (!method_exists($this->class, $this->method)) {
             $message = 'Annotation %s refers to non-existent method %s::%s()';
@@ -163,17 +163,17 @@ private function getMethodAnnotation(SimpleAnnotationReader $annotationReader) :
     }
 
     /**
-     * Proxy to `SimpleAnnotationReader::getPropertyAnnotation()` with validation
+     * Proxy to `AnnotationReader::getPropertyAnnotation()` with validation
      *
-     * @param SimpleAnnotationReader $annotationReader
+     * @param AnnotationReader $annotationReader
      *
      * @return ComponentObjectInterface
      *
      * @throws InvalidReferenceException
      *
-     * @see SimpleAnnotationReader::getPropertyAnnotation()
+     * @see AnnotationReader::getPropertyAnnotation()
      */
-    private function getPropertyAnnotation(SimpleAnnotationReader $annotationReader) : ComponentObjectInterface
+    private function getPropertyAnnotation(AnnotationReader $annotationReader) : ComponentObjectInterface
     {
         if (!property_exists($this->class, $this->property)) {
             $message = 'Annotation %s refers to non-existent property %s::$%s';
@@ -198,17 +198,17 @@ private function getPropertyAnnotation(SimpleAnnotationReader $annotationReader)
     }
 
     /**
-     * Proxy to `SimpleAnnotationReader::getClassAnnotation()` with validation
+     * Proxy to `AnnotationReader::getClassAnnotation()` with validation
      *
-     * @param SimpleAnnotationReader $annotationReader
+     * @param AnnotationReader $annotationReader
      *
      * @return ComponentObjectInterface
      *
      * @throws InvalidReferenceException
      *
-     * @see SimpleAnnotationReader::getClassAnnotation()
+     * @see AnnotationReader::getClassAnnotation()
      */
-    private function getClassAnnotation(SimpleAnnotationReader $annotationReader) : ComponentObjectInterface
+    private function getClassAnnotation(AnnotationReader $annotationReader) : ComponentObjectInterface
     {
         if (!class_exists($this->class)) {
             $message = 'Annotation %s refers to non-existent class %s';

src/Middleware/RequestBodyValidationMiddleware.php

@@ -45,6 +45,11 @@
 class RequestBodyValidationMiddleware implements MiddlewareInterface
 {
 
+    /**
+     * @var bool
+     */
+    private $useCache = false;
+
     /**
      * Constructor of the class
      *
@@ -59,6 +64,14 @@ public function __construct()
         }
     }
 
+    /**
+     * @return void
+     */
+    public function useCache() : void
+    {
+        $this->useCache = true;
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -75,35 +88,15 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
     }
 
     /**
-     * Tries to determine the reflection of an object that contains the `@OpenApi\Operation()` annotation
-     *
-     * @param ServerRequestInterface $request
-     *
-     * @return null|ReflectionClass
-     */
-    protected function fetchOperationSource(ServerRequestInterface $request) : ?ReflectionClass
-    {
-        $route = $request->getAttribute(Route::ATTR_NAME_FOR_ROUTE);
-
-        if ($route instanceof RouteInterface) {
-            return new ReflectionClass(
-                $route->getRequestHandler()
-            );
-        }
-
-        return null;
-    }
-
-    /**
-     * Tries to determine a MIME type for the request body
+     * Tries to determine a media type for the request body
      *
      * @param ServerRequestInterface $request
      *
      * @return string
      *
      * @link https://tools.ietf.org/html/rfc7231#section-3.1.1.1
      */
-    protected function fetchMimeType(ServerRequestInterface $request) : string
+    protected function fetchMediaType(ServerRequestInterface $request) : string
     {
         $result = $request->getHeaderLine('Content-Type');
         $semicolon = strpos($result, ';');
@@ -115,29 +108,6 @@ protected function fetchMimeType(ServerRequestInterface $request) : string
         return $result;
     }
 
-    /**
-     * Tries to determine a JSON schema for the request body
-     *
-     * @param ServerRequestInterface $request
-     *
-     * @return mixed
-     */
-    protected function fetchJsonSchema(ServerRequestInterface $request)
-    {
-        $operationSource = $this->fetchOperationSource($request);
-
-        // it is not recommended to use this middleware globally...
-        if (null === $operationSource) {
-            return null;
-        }
-
-        $builder = new JsonSchemaBuilder($operationSource);
-
-        $mimeType = $this->fetchMimeType($request);
-
-        return $builder->forRequestBody($mimeType);
-    }
-
     /**
      * Validates the given request
      *
@@ -150,8 +120,21 @@ protected function fetchJsonSchema(ServerRequestInterface $request)
      */
     protected function validate(ServerRequestInterface $request) : void
     {
+        $route = $request->getAttribute(Route::ATTR_NAME_FOR_ROUTE);
+        if (!($route instanceof RouteInterface)) {
+            return;
+        }
+
+        $operationSource = new ReflectionClass($route->getRequestHandler());
+        $jsonSchemaBuilder = new JsonSchemaBuilder($operationSource);
+
+        if ($this->useCache) {
+            $jsonSchemaBuilder->useCache();
+        }
+
         try {
-            $jsonSchema = $this->fetchJsonSchema($request);
+            $mediaType = $this->fetchMediaType($request);
+            $jsonSchema = $jsonSchemaBuilder->forRequestBody($mediaType);
         } catch (LocalUnsupportedMediaTypeException $e) {
             throw new UnsupportedMediaTypeException($e->getMessage(), [
                 'type' => $e->getType(),

src/Middleware/RequestQueryValidationMiddleware.php

@@ -41,6 +41,11 @@
 class RequestQueryValidationMiddleware implements MiddlewareInterface
 {
 
+    /**
+     * @var bool
+     */
+    private $useCache = false;
+
     /**
      * Constructor of the class
      *
@@ -55,6 +60,14 @@ public function __construct()
         }
     }
 
+    /**
+     * @return void
+     */
+    public function useCache() : void
+    {
+        $this->useCache = true;
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -82,15 +95,18 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
     protected function validate(ServerRequestInterface $request) : void
     {
         $route = $request->getAttribute(Route::ATTR_NAME_FOR_ROUTE);
-
         if (!($route instanceof RouteInterface)) {
             return;
         }
 
         $operationSource = new ReflectionClass($route->getRequestHandler());
         $jsonSchemaBuilder = new JsonSchemaBuilder($operationSource);
-        $jsonSchema = $jsonSchemaBuilder->forRequestQueryParams();
 
+        if ($this->useCache) {
+            $jsonSchemaBuilder->useCache();
+        }
+
+        $jsonSchema = $jsonSchemaBuilder->forRequestQueryParams();
         if (null === $jsonSchema) {
             return;
         }

src/Utility/JsonSchemaBuilder.php

@@ -14,21 +14,26 @@
 /**
  * Import classes
  */
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\Reader as AnnotationReader;
 use Doctrine\Common\Annotations\SimpleAnnotationReader;
+use Doctrine\Common\Cache\ApcuCache;
 use Sunrise\Http\Router\OpenApi\Annotation\OpenApi\Operation;
 use Sunrise\Http\Router\OpenApi\Annotation\OpenApi\ParameterReference;
 use Sunrise\Http\Router\OpenApi\Annotation\OpenApi\RequestBodyReference;
 use Sunrise\Http\Router\OpenApi\Annotation\OpenApi\ResponseReference;
 use Sunrise\Http\Router\OpenApi\Exception\UnsupportedMediaTypeException;
 use Sunrise\Http\Router\OpenApi\OpenApi;
 use ReflectionClass;
+use RuntimeException;
 
 /**
  * Import functions
  */
 use function array_keys;
 use function array_walk;
 use function array_walk_recursive;
+use function extension_loaded;
 use function str_replace;
 
 /**
@@ -50,10 +55,15 @@ class JsonSchemaBuilder
     private $operationSource;
 
     /**
-     * @var SimpleAnnotationReader
+     * @var AnnotationReader
      */
     private $annotationReader;
 
+    /**
+     * @var bool
+     */
+    private $useCache = false;
+
     /**
      * Constructor of the class
      *
@@ -67,6 +77,42 @@ public function __construct(ReflectionClass $operationSource)
         $this->annotationReader->addNamespace(OpenApi::ANNOTATIONS_NAMESPACE);
     }
 
+    /**
+     * @return ReflectionClass
+     */
+    public function getOperationSource() : ReflectionClass
+    {
+        return $this->operationSource;
+    }
+
+    /**
+     * @return AnnotationReader
+     */
+    public function getAnnotationReader() : AnnotationReader
+    {
+        return $this->annotationReader;
+    }
+
+    /**
+     * @return void
+     *
+     * @throws RuntimeException
+     */
+    public function useCache() : void
+    {
+        if ($this->useCache) {
+            throw new RuntimeException('Cache already used.');
+        }
+
+        if (!extension_loaded('apcu')) {
+            throw new RuntimeException('APCu extension required.');
+        }
+
+        $this->useCache = true;
+
+        $this->annotationReader = new CachedReader($this->annotationReader, new ApcuCache(__CLASS__), false);
+    }
+
     /**
      * Builds a JSON schema for a request query parameters
      *