GraphQLEndpointController::setMiddlewares() - Code Metrics - Inspection of "update CHANGELOG.md" - ynloultratech/graphql-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 9da6fd...0354d3 )

by Rafael
created 2018-06-14 11:08 UTC
GraphQLEndpointController::setMiddlewares() A

↳ Parent: GraphQLEndpointController
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1
crap	1
<?php

/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Controller;

use GraphQL\Error\ClientAware;
use GraphQL\Error\Debug;
use GraphQL\Error\Error;
use GraphQL\GraphQL;
use GraphQL\Validator\DocumentValidator;
use GraphQL\Validator\Rules;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Ynlo\GraphQLBundle\Error\DefaultErrorFormatter;
use Ynlo\GraphQLBundle\Error\DefaultErrorHandler;
use Ynlo\GraphQLBundle\Error\ErrorFormatterInterface;
use Ynlo\GraphQLBundle\Error\ErrorHandlerInterface;
use Ynlo\GraphQLBundle\Error\ErrorQueue;
use Ynlo\GraphQLBundle\Request\ExecuteQuery;
use Ynlo\GraphQLBundle\Request\RequestMiddlewareInterface;
use Ynlo\GraphQLBundle\Resolver\QueryExecutionContext;
use Ynlo\GraphQLBundle\Schema\SchemaCompiler;
use Ynlo\GraphQLBundle\Security\EndpointResolver;

class GraphQLEndpointController
{
    /**
     * @var EndpointResolver
     */
    protected $resolver;

    /**
     * @var SchemaCompiler
     */
    protected $compiler;

    /**
     * App Config
     *
     * @var array
     */
    protected $config = [];

    /**
     * @var ErrorFormatterInterface
     */
    protected $errorFormatter;

    /**
     * @var ErrorHandlerInterface
     */
    protected $errorHandler;

    /**
     * @var bool
     */
    protected $debug = false;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * @var iterable
     */
    protected $middlewares = [];

    /**
     * GraphQLEndpointController constructor.
     *
     * @param EndpointResolver $endpointResolver
     * @param SchemaCompiler   $compiler
     */
    public function __construct(EndpointResolver $endpointResolver, SchemaCompiler $compiler)
    {
        $this->resolver = $endpointResolver;
        $this->compiler = $compiler;
    }

    /**
     * @param ErrorFormatterInterface $errorFormatter
     */
    public function setErrorFormatter(ErrorFormatterInterface $errorFormatter): void
    {
        $this->errorFormatter = $errorFormatter;
    }

    /**
     * @param ErrorHandlerInterface $errorHandler
     */
    public function setErrorHandler(ErrorHandlerInterface $errorHandler): void
    {
        $this->errorHandler = $errorHandler;
    }

    /**
     * @param bool $debug
     */
    public function setDebug(bool $debug): void
    {
        $this->debug = $debug;
    }

    /**
     * @param LoggerInterface|null $logger
     */
    public function setLogger(?LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }

    /**
     * @param array $config
     */
    public function setConfig(array $config): void
    {
        $this->config = $config;
    }

    /**
     * @param iterable $middlewares
     */
    public function setMiddlewares(iterable $middlewares): void
    {
        $this->middlewares = $middlewares;
    }

    public function __invoke(Request $request): JsonResponse
    {
        if (!$this->debug && $request->getMethod() !== Request::METHOD_POST) {
            throw new HttpException(Response::HTTP_BAD_REQUEST, 'The method should be POST to talk with GraphQL API');
        }

        $query = new ExecuteQuery();
        foreach ($this->middlewares as $middleware) {
            if ($middleware instanceof RequestMiddlewareInterface) {
                $middleware->processRequest($request, $query);
            }
        }

        $context = new QueryExecutionContext();
        $validationRules = null;

        try {
            $endpoint = $this->resolver->resolveEndpoint($request);
            if (!$endpoint) {
                throw new AccessDeniedHttpException();
            }

            $schema = $this->compiler->compile($endpoint);
            $schema->assertValid();

            $result = GraphQL::executeQuery(
                $schema,
                $query->getRequestString(),
                null,
                $context,
                $query->getVariables(),
                $query->getOperationName(),
                null,
                $validationRules
            );

            if (!$this->debug) {
                // in case of debug = false
                // If API_DEBUG is passed, output of error formatter is enriched which debugging information.
                // Helpful for tests to get full error logs without the need of enable full app debug flag
                if (isset($_ENV['API_DEBUG'])) {
                    $this->debug = $_ENV['API_DEBUG'];
                } elseif (isset($_SERVER['API_DEBUG'])) {
                    $this->debug = $_SERVER['API_DEBUG'];
                }
            }

            $debugFlags = false;
            if ($this->debug) {
                if ($this->config['error_handling']['show_trace'] ?? true) {
                    $debugFlags = Debug::INCLUDE_DEBUG_MESSAGE | Debug::INCLUDE_TRACE;
                } else {
                    $debugFlags = Debug::INCLUDE_DEBUG_MESSAGE;
                }
            }

            //https://webonyx.github.io/graphql-php/error-handling/
            $formatter = $this->errorFormatter ?? new DefaultErrorFormatter();
            $formatter = $this->errorFormatter ?? /** @scrutinizer ignore-call */ new DefaultErrorFormatter();
            $handler = $this->errorHandler ?? new DefaultErrorHandler($this->logger);

            //get queued errors
            $exceptions = ErrorQueue::all();
            foreach ($exceptions as $exception) {
                $result->errors[] = Error::createLocatedError($exception);
            }

            $result->setErrorFormatter([$formatter, 'format']);
            $result->setErrorsHandler(
                function ($errors) use ($handler, $formatter, $debugFlags) {
                    return $handler->handle($errors, $formatter, $debugFlags);
                }
            );

            $output = $result->toArray($debugFlags);
            $statusCode = Response::HTTP_OK;
        } catch (\Exception $e) {
            if (null !== $this->logger) {
                $this->logger->error($e->getMessage(), $e->getTrace());
            }

            if ($e instanceof HttpException) {
                $message = Response::$statusTexts[$e->getStatusCode()];
                $statusCode = $e->getStatusCode();
            } else {
                $statusCode = Response::HTTP_INTERNAL_SERVER_ERROR;
                $message = 'Internal Server Error';
                if ($this->debug || ($e instanceof ClientAware && $e->isClientSafe())) {
                    $message = $e->getMessage();
                }
            }

            $output['errors']['message'] = $message;
            $output['errors']['category'] = 'internal';

            if ($this->debug) {
                $output['errors']['trace'] = $e->getTraceAsString();
            }
        }

        return JsonResponse::create($output, $statusCode);
    }

    public function addGlobalValidationRules(array $validationRules): void
    {
        $rules = [];
        if (!empty($validationRules['query_complexity'])) {
            $rules[] = new Rules\QueryComplexity($validationRules['query_complexity']);
        }
        if (!empty($validationRules['query_depth'])) {
            $rules[] = new Rules\QueryDepth($validationRules['query_depth']);
        }
        if (!empty($validationRules['disable_introspection'])) {
            $rules[] = new Rules\DisableIntrospection();
        }
        array_map([DocumentValidator::class, 'addRule'], $rules);
    }
}

ynloultratech / graphql-bundle

Push — master ( 9da6fd...0354d3 )

GraphQLEndpointController::setMiddlewares() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
