Ynlo\GraphQLBundle\Controller\GraphQLEndpointController::__invoke()

Complexity

Conditions	19
Paths	3097

Size

Total Lines	88
Code Lines	55

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	35
CRAP Score	31.611

Importance

Changes

0

<?php
    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 = null;
        $validationRules = null;

        try {
            $schema = $this->compiler->compile();
            $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) {
                $debugFlags = Debug::INCLUDE_DEBUG_MESSAGE | Debug::INCLUDE_TRACE;
            }

            foreach ($result->errors as $error) {
                if (null !== $this->logger) {
                    $originError = $error->getTrace()[0]['args'][0] ?? null;
                    $context = [];
                    if ($originError instanceof \Exception) {
                        $context = [
                            'file' => $originError->getFile(),
                            'line' => $originError->getLine(),
                            'error' => get_class($originError),
                        ];
                    }
                    if ($error->isClientSafe()) {
                        $this->logger->notice($error->getMessage(), $context);
                    } else {
                        $this->logger->error($error->getMessage(), $context);
                    }
                }
            }

            $output = $result->toArray($debugFlags);
            $statusCode = Response::HTTP_OK;
        } catch (\Exception $e) {
            if (null !== $this->logger) {
                $this->logger->error($e->getMessage(), $e->getTrace());
            }
            $statusCode = Response::HTTP_INTERNAL_SERVER_ERROR;
            $message = Response::$statusTexts[$statusCode] ?? '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);
    }