vendor/overblog/graphql-bundle/src/Controller/GraphController.php line 59

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Overblog\GraphQLBundle\Controller;
  7. use Overblog\GraphQLBundle\Request as GraphQLRequest;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Symfony\Component\HttpFoundation\Response;
  12. class GraphController
  13. {
  14.     /**
  15.      * @var GraphQLRequest\BatchParser
  16.      */
  17.     private $batchParser;
  19.     /**
  20.      * @var GraphQLRequest\Executor
  21.      */
  22.     private $requestExecutor;
  24.     /**
  25.      * @var GraphQLRequest\Parser
  26.      */
  27.     private $requestParser;
  29.     /**
  30.      * @var bool
  31.      */
  32.     private $shouldHandleCORS;
  34.     /**
  35.      * @var bool
  36.      */
  37.     private $useApolloBatchingMethod;
  39.     public function __construct(
  40.         GraphQLRequest\ParserInterface $batchParser,
  41.         GraphQLRequest\Executor $requestExecutor,
  42.         GraphQLRequest\ParserInterface $requestParser,
  43.         $shouldHandleCORS,
  44.         $graphQLBatchingMethod
  45.     ) {
  46.         $this->batchParser = $batchParser;
  47.         $this->requestExecutor = $requestExecutor;
  48.         $this->requestParser = $requestParser;
  49.         $this->shouldHandleCORS = $shouldHandleCORS;
  50.         $this->useApolloBatchingMethod = 'apollo' === $graphQLBatchingMethod;
  51.     }
  53.     /**
  54.      * @param Request     $request
  55.      * @param string|null $schemaName
  56.      *
  57.      * @return JsonResponse|Response
  58.      */
  59.     public function endpointAction(Request $request, string $schemaName = null)
  60.     {
  61.         return $this->createResponse($request, $schemaName, false);
  62.     }
  64.     /**
  65.      * @param Request     $request
  66.      * @param string|null $schemaName
  67.      *
  68.      * @return JsonResponse|Response
  69.      */
  70.     public function batchEndpointAction(Request $request, string $schemaName = null)
  71.     {
  72.         return $this->createResponse($request, $schemaName, true);
  73.     }
  75.     /**
  76.      * @param Request     $request
  77.      * @param string|null $schemaName
  78.      * @param bool        $batched
  79.      *
  80.      * @return JsonResponse|Response
  81.      */
  82.     private function createResponse(Request $request, string $schemaName = null, bool $batched)
  83.     {
  84.         if ('OPTIONS' === $request->getMethod()) {
  85.             $response = new JsonResponse([], 200);
  86.         } else {
  87.             if (!\in_array($request->getMethod(), ['POST', 'GET'])) {
  88.                 return new Response('', 405);
  89.             }
  90.             $payload = $this->processQuery($request, $schemaName, $batched);
  91.             $response = new JsonResponse($payload, 200);
  92.         }
  93.         $this->addCORSHeadersIfNeeded($response, $request);
  95.         return $response;
  96.     }
  98.     private function addCORSHeadersIfNeeded(Response $response, Request $request): void
  99.     {
  100.         if ($this->shouldHandleCORS && $request->headers->has('Origin')) {
  101.             $response->headers->set('Access-Control-Allow-Origin', $request->headers->get('Origin'), true);
  102.             $response->headers->set('Access-Control-Allow-Credentials', 'true', true);
  103.             $response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization', true);
  104.             $response->headers->set('Access-Control-Allow-Methods', 'OPTIONS, GET, POST', true);
  105.             $response->headers->set('Access-Control-Max-Age', '3600', true);
  106.         }
  107.     }
  109.     /**
  110.      * @param Request     $request
  111.      * @param string|null $schemaName
  112.      * @param bool        $batched
  113.      *
  114.      * @return array
  115.      */
  116.     private function processQuery(Request $request, string $schemaName = null, bool $batched): array
  117.     {
  118.         if ($batched) {
  119.             $payload = $this->processBatchQuery($request, $schemaName);
  120.         } else {
  121.             $payload = $this->processNormalQuery($request, $schemaName);
  122.         }
  124.         return $payload;
  125.     }
  127.     /**
  128.      * @param Request     $request
  129.      * @param string|null $schemaName
  130.      *
  131.      * @return array
  132.      */
  133.     private function processBatchQuery(Request $request, string $schemaName = null): array
  134.     {
  135.         $queries = $this->batchParser->parse($request);
  136.         $payloads = [];
  138.         foreach ($queries as $query) {
  139.             $payload = $this->requestExecutor
  140.                 ->execute($schemaName, $query)
  141.                 ->toArray();
  142.             if (!$this->useApolloBatchingMethod) {
  143.                 $payload = ['id' => $query['id'], 'payload' => $payload];
  144.             }
  145.             $payloads[] = $payload;
  146.         }
  148.         return $payloads;
  149.     }
  151.     /**
  152.      * @param Request     $request
  153.      * @param string|null $schemaName
  154.      *
  155.      * @return array
  156.      */
  157.     private function processNormalQuery(Request $request, string $schemaName = null): array
  158.     {
  159.         $params = $this->requestParser->parse($request);
  161.         return $this->requestExecutor->execute($schemaName, $params)->toArray();
  162.     }
  163. }