vendor/overblog/graphql-bundle/src/DataCollector/GraphQLCollector.php line 101

  1. <?php
  3. declare(strict_types=1);
  5. namespace Overblog\GraphQLBundle\DataCollector;
  7. use GraphQL\Error\SyntaxError;
  8. use GraphQL\Language\AST\DocumentNode;
  9. use GraphQL\Language\AST\FieldNode;
  10. use GraphQL\Language\AST\OperationDefinitionNode;
  11. use GraphQL\Language\Parser;
  12. use Overblog\GraphQLBundle\Event\ExecutorResultEvent;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\HttpKernel\DataCollector\DataCollector;
  16. use Throwable;
  17. use function count;
  18. use function microtime;
  20. class GraphQLCollector extends DataCollector
  21. {
  22.     /**
  23.      * GraphQL Batches executed.
  24.      */
  25.     protected array $batches = [];
  27.     public function collect(Request $request, Response $response, Throwable $exception = null): void
  28.     {
  29.         $error = false;
  30.         $count = 0;
  31.         $schema = null;
  32.         foreach ($this->batches as $batch) {
  33.             if (!$schema) {
  34.                 $schema = $batch['schema'];
  35.             }
  36.             if (isset($batch['error'])) {
  37.                 $error = true;
  38.             }
  39.             $count += $batch['count'];
  40.         }
  42.         $this->data = [
  43.             'schema' => $schema,
  44.             'batches' => $this->batches,
  45.             'count' => $count,
  46.             'error' => $error,
  47.         ];
  48.     }
  50.     /**
  51.      * Check if we have an error.
  52.      */
  53.     public function getError(): bool
  54.     {
  55.         return $this->data['error'] ?? false;
  56.     }
  58.     /**
  59.      * Count the number of executed queries.
  60.      */
  61.     public function getCount(): int
  62.     {
  63.         return $this->data['count'] ?? 0;
  64.     }
  66.     /**
  67.      * Return the targeted schema.
  68.      */
  69.     public function getSchema(): ?string
  70.     {
  71.         return $this->data['schema'];
  72.     }
  74.     /**
  75.      * Return the list of executed batch.
  76.      */
  77.     public function getBatches(): array
  78.     {
  79.         return $this->data['batches'] ?? [];
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function reset(): void
  86.     {
  87.         $this->data = [];
  88.     }
  90.     /**
  91.      * {@inheritdoc}
  92.      */
  93.     public function getName(): string
  94.     {
  95.         return 'graphql';
  96.     }
  98.     /**
  99.      * Hook into the GraphQL events to populate the collector.
  100.      */
  101.     public function onPostExecutor(ExecutorResultEvent $event): void
  102.     {
  103.         $executorArgument = $event->getExecutorArguments();
  104.         $queryString = $executorArgument->getRequestString();
  105.         $operationName = $executorArgument->getOperationName();
  106.         $variables = $executorArgument->getVariableValue();
  107.         $queryTime = microtime(true) - $executorArgument->getStartTime();
  109.         $result = $event->getResult()->toArray();
  111.         $batch = [
  112.             'schema' => $executorArgument->getSchemaName(),
  113.             'queryString' => $queryString,
  114.             'queryTime' => $queryTime,
  115.             'variables' => $this->cloneVar($variables),
  116.             'result' => $this->cloneVar($result),
  117.             'count' => 0,
  118.         ];
  120.         try {
  121.             $parsed = Parser::parse($queryString);
  122.             $batch['graphql'] = $this->extractGraphql($parsed, $operationName);
  123.             if (isset($batch['graphql']['fields'])) {
  124.                 $batch['count'] += count($batch['graphql']['fields']);
  125.             }
  126.             $error = $result['errors'][0] ?? false;
  127.             if ($error) {
  128.                 $batch['error'] = [
  129.                     'message' => $error['message'],
  130.                     'location' => $error['locations'][0] ?? false,
  131.                 ];
  132.             }
  133.         } catch (SyntaxError $error) {
  134.             $location = $error->getLocations()[0] ?? false;
  135.             $batch['error'] = ['message' => $error->getMessage(), 'location' => $location];
  136.         }
  138.         $this->batches[] = $batch;
  139.     }
  141.     /**
  142.      * Extract GraphQL Information from the documentNode.
  143.      */
  144.     protected function extractGraphql(DocumentNode $document, ?string $operationName): array
  145.     {
  146.         $operation = null;
  147.         $fields = [];
  149.         foreach ($document->definitions as $definition) {
  150.             if ($definition instanceof OperationDefinitionNode) {
  151.                 $definitionOperation = $definition->name->value ?? null;
  152.                 if ($operationName != $definitionOperation) {
  153.                     continue;
  154.                 }
  156.                 $operation = $definition->operation;
  157.                 foreach ($definition->selectionSet->selections as $selection) {
  158.                     if ($selection instanceof FieldNode) {
  159.                         $name = $selection->name->value;
  160.                         $alias = $selection->alias ? $selection->alias->value : null;
  162.                         $fields[] = [
  163.                             'name' => $name,
  164.                             'alias' => $alias,
  165.                         ];
  166.                     }
  167.                 }
  168.             }
  169.         }
  171.         return [
  172.             'operation' => $operation,
  173.             'operationName' => $operationName,
  174.             'fields' => $fields,
  175.         ];
  176.     }
  177. }