vendor/webonyx/graphql-php/src/GraphQL.php line 91

  1. <?php declare(strict_types=1);
  3. namespace GraphQL;
  5. use GraphQL\Error\Error;
  6. use GraphQL\Error\InvariantViolation;
  7. use GraphQL\Executor\ExecutionResult;
  8. use GraphQL\Executor\Executor;
  9. use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
  10. use GraphQL\Executor\Promise\Promise;
  11. use GraphQL\Executor\Promise\PromiseAdapter;
  12. use GraphQL\Language\AST\DocumentNode;
  13. use GraphQL\Language\Parser;
  14. use GraphQL\Language\Source;
  15. use GraphQL\Type\Definition\Directive;
  16. use GraphQL\Type\Definition\ScalarType;
  17. use GraphQL\Type\Definition\Type;
  18. use GraphQL\Type\Schema as SchemaType;
  19. use GraphQL\Validator\DocumentValidator;
  20. use GraphQL\Validator\Rules\QueryComplexity;
  21. use GraphQL\Validator\Rules\ValidationRule;
  23. /**
  24.  * This is the primary facade for fulfilling GraphQL operations.
  25.  * See [related documentation](executing-queries.md).
  26.  *
  27.  * @phpstan-import-type FieldResolver from Executor
  28.  */
  29. class GraphQL
  30. {
  31.     /**
  32.      * Executes graphql query.
  33.      *
  34.      * More sophisticated GraphQL servers, such as those which persist queries,
  35.      * may wish to separate the validation and execution phases to a static time
  36.      * tooling step, and a server runtime step.
  37.      *
  38.      * Available options:
  39.      *
  40.      * schema:
  41.      *    The GraphQL type system to use when validating and executing a query.
  42.      * source:
  43.      *    A GraphQL language formatted string representing the requested operation.
  44.      * rootValue:
  45.      *    The value provided as the first argument to resolver functions on the top
  46.      *    level type (e.g. the query object type).
  47.      * contextValue:
  48.      *    The context value is provided as an argument to resolver functions after
  49.      *    field arguments. It is used to pass shared information useful at any point
  50.      *    during executing this query, for example the currently logged in user and
  51.      *    connections to databases or other services.
  52.      * variableValues:
  53.      *    A mapping of variable name to runtime value to use for all variables
  54.      *    defined in the requestString.
  55.      * operationName:
  56.      *    The name of the operation to use if requestString contains multiple
  57.      *    possible operations. Can be omitted if requestString contains only
  58.      *    one operation.
  59.      * fieldResolver:
  60.      *    A resolver function to use when one is not provided by the schema.
  61.      *    If not provided, the default field resolver is used (which looks for a
  62.      *    value on the source value with the field's name).
  63.      * validationRules:
  64.      *    A set of rules for query validation step. Default value is all available rules.
  65.      *    Empty array would allow to skip query validation (may be convenient for persisted
  66.      *    queries which are validated before persisting and assumed valid during execution)
  67.      *
  68.      * @param string|DocumentNode        $source
  69.      * @param mixed                      $rootValue
  70.      * @param mixed                      $contextValue
  71.      * @param array<string, mixed>|null  $variableValues
  72.      * @param array<ValidationRule>|null $validationRules
  73.      *
  74.      * @api
  75.      *
  76.      * @throws \Exception
  77.      * @throws InvariantViolation
  78.      */
  79.     public static function executeQuery(
  80.         SchemaType $schema,
  81.         $source,
  82.         $rootValue = null,
  83.         $contextValue = null,
  84.         ?array $variableValues = null,
  85.         ?string $operationName = null,
  86.         ?callable $fieldResolver = null,
  87.         ?array $validationRules = null
  88.     ): ExecutionResult {
  89.         $promiseAdapter = new SyncPromiseAdapter();
  91.         $promise = self::promiseToExecute(
  92.             $promiseAdapter,
  93.             $schema,
  94.             $source,
  95.             $rootValue,
  96.             $contextValue,
  97.             $variableValues,
  98.             $operationName,
  99.             $fieldResolver,
  100.             $validationRules
  101.         );
  103.         return $promiseAdapter->wait($promise);
  104.     }
  106.     /**
  107.      * Same as executeQuery(), but requires PromiseAdapter and always returns a Promise.
  108.      * Useful for Async PHP platforms.
  109.      *
  110.      * @param string|DocumentNode        $source
  111.      * @param mixed                      $rootValue
  112.      * @param mixed                      $context
  113.      * @param array<string, mixed>|null  $variableValues
  114.      * @param array<ValidationRule>|null $validationRules
  115.      *
  116.      * @api
  117.      *
  118.      * @throws \Exception
  119.      */
  120.     public static function promiseToExecute(
  121.         PromiseAdapter $promiseAdapter,
  122.         SchemaType $schema,
  123.         $source,
  124.         $rootValue = null,
  125.         $context = null,
  126.         ?array $variableValues = null,
  127.         ?string $operationName = null,
  128.         ?callable $fieldResolver = null,
  129.         ?array $validationRules = null
  130.     ): Promise {
  131.         try {
  132.             $documentNode = $source instanceof DocumentNode
  133.                 ? $source
  134.                 : Parser::parse(new Source($source, 'GraphQL'));
  136.             if ($validationRules === null || $validationRules === []) {
  137.                 $queryComplexity = DocumentValidator::getRule(QueryComplexity::class);
  138.                 assert($queryComplexity instanceof QueryComplexity, 'should not register a different rule for QueryComplexity');
  140.                 $queryComplexity->setRawVariableValues($variableValues);
  141.             } else {
  142.                 foreach ($validationRules as $rule) {
  143.                     if ($rule instanceof QueryComplexity) {
  144.                         $rule->setRawVariableValues($variableValues);
  145.                     }
  146.                 }
  147.             }
  149.             $validationErrors = DocumentValidator::validate($schema, $documentNode, $validationRules);
  151.             if ($validationErrors !== []) {
  152.                 return $promiseAdapter->createFulfilled(
  153.                     new ExecutionResult(null, $validationErrors)
  154.                 );
  155.             }
  157.             return Executor::promiseToExecute(
  158.                 $promiseAdapter,
  159.                 $schema,
  160.                 $documentNode,
  161.                 $rootValue,
  162.                 $context,
  163.                 $variableValues,
  164.                 $operationName,
  165.                 $fieldResolver
  166.             );
  167.         } catch (Error $e) {
  168.             return $promiseAdapter->createFulfilled(
  169.                 new ExecutionResult(null, [$e])
  170.             );
  171.         }
  172.     }
  174.     /**
  175.      * Returns directives defined in GraphQL spec.
  176.      *
  177.      * @throws InvariantViolation
  178.      *
  179.      * @return array<string, Directive>
  180.      *
  181.      * @api
  182.      */
  183.     public static function getStandardDirectives(): array
  184.     {
  185.         return Directive::getInternalDirectives();
  186.     }
  188.     /**
  189.      * Returns types defined in GraphQL spec.
  190.      *
  191.      * @throws InvariantViolation
  192.      *
  193.      * @return array<string, ScalarType>
  194.      *
  195.      * @api
  196.      */
  197.     public static function getStandardTypes(): array
  198.     {
  199.         return Type::getStandardTypes();
  200.     }
  202.     /**
  203.      * Replaces standard types with types from this list (matching by name).
  204.      *
  205.      * Standard types not listed here remain untouched.
  206.      *
  207.      * @param array<string, ScalarType> $types
  208.      *
  209.      * @api
  210.      *
  211.      * @throws InvariantViolation
  212.      */
  213.     public static function overrideStandardTypes(array $types): void
  214.     {
  215.         Type::overrideStandardTypes($types);
  216.     }
  218.     /**
  219.      * Returns standard validation rules implementing GraphQL spec.
  220.      *
  221.      * @return array<class-string<ValidationRule>, ValidationRule>
  222.      *
  223.      * @api
  224.      */
  225.     public static function getStandardValidationRules(): array
  226.     {
  227.         return DocumentValidator::defaultRules();
  228.     }
  230.     /**
  231.      * Set default resolver implementation.
  232.      *
  233.      * @phpstan-param FieldResolver $fn
  234.      *
  235.      * @api
  236.      */
  237.     public static function setDefaultFieldResolver(callable $fn): void
  238.     {
  239.         Executor::setDefaultFieldResolver($fn);
  240.     }
  241. }