vendor/webonyx/graphql-php/src/Executor/Executor.php line 142

  1. <?php declare(strict_types=1);
  3. namespace GraphQL\Executor;
  5. use GraphQL\Error\InvariantViolation;
  6. use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
  7. use GraphQL\Executor\Promise\Promise;
  8. use GraphQL\Executor\Promise\PromiseAdapter;
  9. use GraphQL\Language\AST\DocumentNode;
  10. use GraphQL\Type\Definition\ResolveInfo;
  11. use GraphQL\Type\Schema;
  12. use GraphQL\Utils\Utils;
  14. /**
  15.  * Implements the "Evaluating requests" section of the GraphQL specification.
  16.  *
  17.  * @phpstan-type FieldResolver callable(mixed, array<string, mixed>, mixed, ResolveInfo): mixed
  18.  * @phpstan-type ImplementationFactory callable(PromiseAdapter, Schema, DocumentNode, mixed, mixed, array<mixed>, ?string, callable): ExecutorImplementation
  19.  */
  20. class Executor
  21. {
  22.     /**
  23.      * @var callable
  24.      *
  25.      * @phpstan-var FieldResolver
  26.      */
  27.     private static $defaultFieldResolver = [self::class, 'defaultFieldResolver'];
  29.     private static ?PromiseAdapter $defaultPromiseAdapter;
  31.     /**
  32.      * @var callable
  33.      *
  34.      * @phpstan-var ImplementationFactory
  35.      */
  36.     private static $implementationFactory = [ReferenceExecutor::class, 'create'];
  38.     /**
  39.      * @phpstan-return FieldResolver
  40.      */
  41.     public static function getDefaultFieldResolver(): callable
  42.     {
  43.         return self::$defaultFieldResolver;
  44.     }
  46.     /**
  47.      * Set a custom default resolve function.
  48.      *
  49.      * @phpstan-param FieldResolver $fieldResolver
  50.      */
  51.     public static function setDefaultFieldResolver(callable $fieldResolver): void
  52.     {
  53.         self::$defaultFieldResolver = $fieldResolver;
  54.     }
  56.     public static function getPromiseAdapter(): PromiseAdapter
  57.     {
  58.         return self::$defaultPromiseAdapter ??= new SyncPromiseAdapter();
  59.     }
  61.     /**
  62.      * Set a custom default promise adapter.
  63.      */
  64.     public static function setPromiseAdapter(?PromiseAdapter $defaultPromiseAdapter = null): void
  65.     {
  66.         self::$defaultPromiseAdapter = $defaultPromiseAdapter;
  67.     }
  69.     /**
  70.      * @phpstan-return ImplementationFactory
  71.      */
  72.     public static function getImplementationFactory(): callable
  73.     {
  74.         return self::$implementationFactory;
  75.     }
  77.     /**
  78.      * Set a custom executor implementation factory.
  79.      *
  80.      * @phpstan-param ImplementationFactory $implementationFactory
  81.      */
  82.     public static function setImplementationFactory(callable $implementationFactory): void
  83.     {
  84.         self::$implementationFactory = $implementationFactory;
  85.     }
  87.     /**
  88.      * Executes DocumentNode against given $schema.
  89.      *
  90.      * Always returns ExecutionResult and never throws.
  91.      * All errors which occur during operation execution are collected in `$result->errors`.
  92.      *
  93.      * @param mixed                     $rootValue
  94.      * @param mixed                     $contextValue
  95.      * @param array<string, mixed>|null $variableValues
  96.      *
  97.      * @phpstan-param FieldResolver|null $fieldResolver
  98.      *
  99.      * @api
  100.      *
  101.      * @throws InvariantViolation
  102.      */
  103.     public static function execute(
  104.         Schema $schema,
  105.         DocumentNode $documentNode,
  106.         $rootValue = null,
  107.         $contextValue = null,
  108.         ?array $variableValues = null,
  109.         ?string $operationName = null,
  110.         ?callable $fieldResolver = null
  111.     ): ExecutionResult {
  112.         $promiseAdapter = new SyncPromiseAdapter();
  114.         $result = static::promiseToExecute(
  115.             $promiseAdapter,
  116.             $schema,
  117.             $documentNode,
  118.             $rootValue,
  119.             $contextValue,
  120.             $variableValues,
  121.             $operationName,
  122.             $fieldResolver
  123.         );
  125.         return $promiseAdapter->wait($result);
  126.     }
  128.     /**
  129.      * Same as execute(), but requires promise adapter and returns a promise which is always
  130.      * fulfilled with an instance of ExecutionResult and never rejected.
  131.      *
  132.      * Useful for async PHP platforms.
  133.      *
  134.      * @param mixed                     $rootValue
  135.      * @param mixed                     $contextValue
  136.      * @param array<string, mixed>|null $variableValues
  137.      *
  138.      * @phpstan-param FieldResolver|null $fieldResolver
  139.      *
  140.      * @api
  141.      */
  142.     public static function promiseToExecute(
  143.         PromiseAdapter $promiseAdapter,
  144.         Schema $schema,
  145.         DocumentNode $documentNode,
  146.         $rootValue = null,
  147.         $contextValue = null,
  148.         ?array $variableValues = null,
  149.         ?string $operationName = null,
  150.         ?callable $fieldResolver = null
  151.     ): Promise {
  152.         $executor = (self::$implementationFactory)(
  153.             $promiseAdapter,
  154.             $schema,
  155.             $documentNode,
  156.             $rootValue,
  157.             $contextValue,
  158.             $variableValues ?? [],
  159.             $operationName,
  160.             $fieldResolver ?? self::$defaultFieldResolver
  161.         );
  163.         return $executor->doExecute();
  164.     }
  166.     /**
  167.      * If a resolve function is not given, then a default resolve behavior is used
  168.      * which takes the property of the root value of the same name as the field
  169.      * and returns it as the result, or if it's a function, returns the result
  170.      * of calling that function while passing along args and context.
  171.      *
  172.      * @param mixed $objectLikeValue
  173.      * @param array<string, mixed> $args
  174.      * @param mixed $contextValue
  175.      *
  176.      * @return mixed
  177.      */
  178.     public static function defaultFieldResolver($objectLikeValue, array $args, $contextValue, ResolveInfo $info)
  179.     {
  180.         $property = Utils::extractKey($objectLikeValue, $info->fieldName);
  182.         return $property instanceof \Closure
  183.             ? $property($objectLikeValue, $args, $contextValue, $info)
  184.             : $property;
  185.     }
  186. }