Version 4.5.0

system/3rd_party/graphql-php/Executor/ExecutionContext.php

@@ -0,0 +1,87 @@
+<?php
+namespace GraphQL\Executor;
+
+use GraphQL\Error\Error;
+use GraphQL\Language\AST\FragmentDefinitionNode;
+use GraphQL\Language\AST\OperationDefinitionNode;
+use GraphQL\Type\Schema;
+
+/**
+ * Data that must be available at all points during query execution.
+ *
+ * Namely, schema of the type system that is currently executing,
+ * and the fragments defined in the query document
+ *
+ * @internal
+ */
+class ExecutionContext
+{
+    /**
+     * @var Schema
+     */
+    public $schema;
+
+    /**
+     * @var FragmentDefinitionNode[]
+     */
+    public $fragments;
+
+    /**
+     * @var mixed
+     */
+    public $rootValue;
+
+    /**
+     * @var mixed
+     */
+    public $contextValue;
+
+    /**
+     * @var OperationDefinitionNode
+     */
+    public $operation;
+
+    /**
+     * @var array
+     */
+    public $variableValues;
+
+    /**
+     * @var callable
+     */
+    public $fieldResolver;
+
+    /**
+     * @var array
+     */
+    public $errors;
+
+    public function __construct(
+        $schema,
+        $fragments,
+        $root,
+        $contextValue,
+        $operation,
+        $variables,
+        $errors,
+        $fieldResolver,
+        $promiseAdapter
+    )
+    {
+        $this->schema = $schema;
+        $this->fragments = $fragments;
+        $this->rootValue = $root;
+        $this->contextValue = $contextValue;
+        $this->operation = $operation;
+        $this->variableValues = $variables;
+        $this->errors = $errors ?: [];
+        $this->fieldResolver = $fieldResolver;
+        $this->promises = $promiseAdapter;
+    }
+
+    public function addError(Error $error)
+    {
+        $this->errors[] = $error;
+        return $this;
+    }
+}

system/3rd_party/graphql-php/Executor/ExecutionResult.php

@@ -0,0 +1,158 @@
+<?php
+namespace GraphQL\Executor;
+
+use GraphQL\Error\Error;
+use GraphQL\Error\FormattedError;
+
+/**
+ * Returned after [query execution](executing-queries.md).
+ * Represents both - result of successful execution and of a failed one
+ * (with errors collected in `errors` prop)
+ *
+ * Could be converted to [spec-compliant](https://facebook.github.io/graphql/#sec-Response-Format)
+ * serializable array using `toArray()`
+ */
+class ExecutionResult implements \JsonSerializable
+{
+    /**
+     * Data collected from resolvers during query execution
+     *
+     * @api
+     * @var array
+     */
+    public $data;
+
+    /**
+     * Errors registered during query execution.
+     *
+     * If an error was caused by exception thrown in resolver, $error->getPrevious() would
+     * contain original exception.
+     *
+     * @api
+     * @var \GraphQL\Error\Error[]
+     */
+    public $errors;
+    
+    /**
+     * User-defined serializable array of extensions included in serialized result.
+     * Conforms to
+     *
+     * @api
+     * @var array
+     */
+    public $extensions;
+
+    /**
+     * @var callable
+     */
+    private $errorFormatter;
+
+    /**
+     * @var callable
+     */
+    private $errorsHandler;
+
+    /**
+     * @param array $data
+     * @param array $errors
+     * @param array $extensions
+     */
+    public function __construct(array $data = null, array $errors = [], array $extensions = [])
+    {
+        $this->data = $data;
+        $this->errors = $errors;
+        $this->extensions = $extensions;
+    }
+
+    /**
+     * Define custom error formatting (must conform to http://facebook.github.io/graphql/#sec-Errors)
+     *
+     * Expected signature is: function (GraphQL\Error\Error $error): array
+     *
+     * Default formatter is "GraphQL\Error\FormattedError::createFromException"
+     *
+     * Expected returned value must be an array:
+     * array(
+     *    'message' => 'errorMessage',
+     *    // ... other keys
+     * );
+     *
+     * @api
+     * @param callable $errorFormatter
+     * @return $this
+     */
+    public function setErrorFormatter(callable $errorFormatter)
+    {
+        $this->errorFormatter = $errorFormatter;
+        return $this;
+    }
+
+    /**
+     * Define custom logic for error handling (filtering, logging, etc).
+     *
+     * Expected handler signature is: function (array $errors, callable $formatter): array
+     *
+     * Default handler is:
+     * function (array $errors, callable $formatter) {
+     *     return array_map($formatter, $errors);
+     * }
+     *
+     * @api
+     * @param callable $handler
+     * @return $this
+     */
+    public function setErrorsHandler(callable $handler)
+    {
+        $this->errorsHandler = $handler;
+        return $this;
+    }
+
+    /**
+     * Converts GraphQL query result to spec-compliant serializable array using provided
+     * errors handler and formatter.
+     *
+     * If debug argument is passed, output of error formatter is enriched which debugging information
+     * ("debugMessage", "trace" keys depending on flags).
+     *
+     * $debug argument must be either bool (only adds "debugMessage" to result) or sum of flags from
+     * GraphQL\Error\Debug
+     *
+     * @api
+     * @param bool|int $debug
+     * @return array
+     */
+    public function toArray($debug = false)
+    {
+        $result = [];
+
+        if (!empty($this->errors)) {
+            $errorsHandler = $this->errorsHandler ?: function(array $errors, callable $formatter) {
+                return array_map($formatter, $errors);
+            };
+            $result['errors'] = $errorsHandler(
+                $this->errors,
+                FormattedError::prepareFormatter($this->errorFormatter, $debug)
+            );
+        }
+
+        if (null !== $this->data) {
+            $result['data'] = $this->data;
+        }
+        
+        if (!empty($this->extensions)) {
+            $result['extensions'] = (array) $this->extensions;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Part of \JsonSerializable interface
+     *
+     * @return array
+     */
+    public function jsonSerialize()
+    {
+        return $this->toArray();
+    }
+}

system/3rd_party/graphql-php/Executor/Promise/Adapter/ReactPromiseAdapter.php

@@ -0,0 +1,86 @@
+<?php
+namespace GraphQL\Executor\Promise\Adapter;
+
+use GraphQL\Executor\Promise\Promise;
+use GraphQL\Executor\Promise\PromiseAdapter;
+use GraphQL\Utils\Utils;
+use React\Promise\Promise as ReactPromise;
+use React\Promise\PromiseInterface as ReactPromiseInterface;
+
+class ReactPromiseAdapter implements PromiseAdapter
+{
+    /**
+     * @inheritdoc
+     */
+    public function isThenable($value)
+    {
+        return $value instanceof ReactPromiseInterface;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function convertThenable($thenable)
+    {
+        return new Promise($thenable, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function then(Promise $promise, callable $onFulfilled = null, callable $onRejected = null)
+    {
+        /** @var $adoptedPromise ReactPromiseInterface */
+        $adoptedPromise = $promise->adoptedPromise;
+        return new Promise($adoptedPromise->then($onFulfilled, $onRejected), $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function create(callable $resolver)
+    {
+        $promise = new ReactPromise($resolver);
+        return new Promise($promise, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function createFulfilled($value = null)
+    {
+        $promise = \React\Promise\resolve($value);
+        return new Promise($promise, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function createRejected($reason)
+    {
+        $promise = \React\Promise\reject($reason);
+        return new Promise($promise, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function all(array $promisesOrValues)
+    {
+        // TODO: rework with generators when PHP minimum required version is changed to 5.5+
+        $promisesOrValues = Utils::map($promisesOrValues, function ($item) {
+            return $item instanceof Promise ? $item->adoptedPromise : $item;
+        });
+
+        $promise = \React\Promise\all($promisesOrValues)->then(function($values) use ($promisesOrValues) {
+            $orderedResults = [];
+
+            foreach ($promisesOrValues as $key => $value) {
+                $orderedResults[$key] = $values[$key];
+            }
+
+            return $orderedResults;
+        });
+        return new Promise($promise, $this);
+    }
+}

system/3rd_party/graphql-php/Executor/Promise/Adapter/SyncPromise.php

@@ -0,0 +1,158 @@
+<?php
+namespace GraphQL\Executor\Promise\Adapter;
+
+use GraphQL\Utils\Utils;
+
+/**
+ * Class SyncPromise
+ *
+ * Simplistic (yet full-featured) implementation of Promises A+ spec for regular PHP `sync` mode
+ * (using queue to defer promises execution)
+ *
+ * @package GraphQL\Executor\Promise\Adapter
+ */
+class SyncPromise
+{
+    const PENDING = 'pending';
+    const FULFILLED = 'fulfilled';
+    const REJECTED = 'rejected';
+
+    /**
+     * @var \SplQueue
+     */
+    public static $queue;
+
+    public static function getQueue()
+    {
+        return self::$queue ?: self::$queue = new \SplQueue();
+    }
+
+    public static function runQueue()
+    {
+        $q = self::$queue;
+        while ($q && !$q->isEmpty()) {
+            $task = $q->dequeue();
+            $task();
+        }
+    }
+
+    public $state = self::PENDING;
+
+    public $result;
+
+    /**
+     * Promises created in `then` method of this promise and awaiting for resolution of this promise
+     * @var array
+     */
+    private $waiting = [];
+
+    public function reject($reason)
+    {
+        if (!$reason instanceof \Exception && !$reason instanceof \Throwable) {
+            throw new \Exception('SyncPromise::reject() has to be called with an instance of \Throwable');
+        }
+
+        switch ($this->state) {
+            case self::PENDING:
+                $this->state = self::REJECTED;
+                $this->result = $reason;
+                $this->enqueueWaitingPromises();
+                break;
+            case self::REJECTED:
+                if ($reason !== $this->result) {
+                    throw new \Exception("Cannot change rejection reason");
+                }
+                break;
+            case self::FULFILLED:
+                throw new \Exception("Cannot reject fulfilled promise");
+        }
+        return $this;
+    }
+
+    public function resolve($value)
+    {
+        switch ($this->state) {
+            case self::PENDING:
+                if ($value === $this) {
+                    throw new \Exception("Cannot resolve promise with self");
+                }
+                if (is_object($value) && method_exists($value, 'then')) {
+                    $value->then(
+                        function($resolvedValue) {
+                            $this->resolve($resolvedValue);
+                        },
+                        function($reason) {
+                            $this->reject($reason);
+                        }
+                    );
+                    return $this;
+                }
+
+                $this->state = self::FULFILLED;
+                $this->result = $value;
+                $this->enqueueWaitingPromises();
+                break;
+            case self::FULFILLED:
+                if ($this->result !== $value) {
+                    throw new \Exception("Cannot change value of fulfilled promise");
+                }
+                break;
+            case self::REJECTED:
+                throw new \Exception("Cannot resolve rejected promise");
+        }
+        return $this;
+    }
+
+    public function then(callable $onFulfilled = null, callable $onRejected = null)
+    {
+        if ($this->state === self::REJECTED && !$onRejected) {
+            return $this;
+        }
+        if ($this->state === self::FULFILLED && !$onFulfilled) {
+            return $this;
+        }
+        $tmp = new self();
+        $this->waiting[] = [$tmp, $onFulfilled, $onRejected];
+
+        if ($this->state !== self::PENDING) {
+            $this->enqueueWaitingPromises();
+        }
+
+        return $tmp;
+    }
+
+    private function enqueueWaitingPromises()
+    {
+        Utils::invariant($this->state !== self::PENDING, 'Cannot enqueue derived promises when parent is still pending');
+
+        foreach ($this->waiting as $descriptor) {
+            self::getQueue()->enqueue(function () use ($descriptor) {
+                /** @var $promise self */
+                list($promise, $onFulfilled, $onRejected) = $descriptor;
+
+                if ($this->state === self::FULFILLED) {
+                    try {
+                        $promise->resolve($onFulfilled ? $onFulfilled($this->result) : $this->result);
+                    } catch (\Exception $e) {
+                        $promise->reject($e);
+                    } catch (\Throwable $e) {
+                        $promise->reject($e);
+                    }
+                } else if ($this->state === self::REJECTED) {
+                    try {
+                        if ($onRejected) {
+                            $promise->resolve($onRejected($this->result));
+                        } else {
+                            $promise->reject($this->result);
+                        }
+                    } catch (\Exception $e) {
+                        $promise->reject($e);
+                    } catch (\Throwable $e) {
+                        $promise->reject($e);
+                    }
+                }
+            });
+        }
+        $this->waiting = [];
+    }
+}

system/3rd_party/graphql-php/Executor/Promise/Adapter/SyncPromiseAdapter.php

@@ -0,0 +1,173 @@
+<?php
+namespace GraphQL\Executor\Promise\Adapter;
+
+use GraphQL\Deferred;
+use GraphQL\Error\InvariantViolation;
+use GraphQL\Executor\Promise\Promise;
+use GraphQL\Executor\Promise\PromiseAdapter;
+use GraphQL\Utils\Utils;
+
+/**
+ * Class SyncPromiseAdapter
+ *
+ * Allows changing order of field resolution even in sync environments
+ * (by leveraging queue of deferreds and promises)
+ *
+ * @package GraphQL\Executor\Promise\Adapter
+ */
+class SyncPromiseAdapter implements PromiseAdapter
+{
+    /**
+     * @inheritdoc
+     */
+    public function isThenable($value)
+    {
+        return $value instanceof Deferred;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function convertThenable($thenable)
+    {
+        if (!$thenable instanceof Deferred) {
+            throw new InvariantViolation('Expected instance of GraphQL\Deferred, got ' . Utils::printSafe($thenable));
+        }
+        return new Promise($thenable->promise, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function then(Promise $promise, callable $onFulfilled = null, callable $onRejected = null)
+    {
+        /** @var SyncPromise $promise */
+        $promise = $promise->adoptedPromise;
+        return new Promise($promise->then($onFulfilled, $onRejected), $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function create(callable $resolver)
+    {
+        $promise = new SyncPromise();
+
+        try {
+            $resolver(
+                [$promise, 'resolve'],
+                [$promise, 'reject']
+            );
+        } catch (\Exception $e) {
+            $promise->reject($e);
+        } catch (\Throwable $e) {
+            $promise->reject($e);
+        }
+
+        return new Promise($promise, $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function createFulfilled($value = null)
+    {
+        $promise = new SyncPromise();
+        return new Promise($promise->resolve($value), $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function createRejected($reason)
+    {
+        $promise = new SyncPromise();
+        return new Promise($promise->reject($reason), $this);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function all(array $promisesOrValues)
+    {
+        $all = new SyncPromise();
+
+        $total = count($promisesOrValues);
+        $count = 0;
+        $result = [];
+
+        foreach ($promisesOrValues as $index => $promiseOrValue) {
+            if ($promiseOrValue instanceof Promise) {
+                $result[$index] = null;
+                $promiseOrValue->then(
+                    function($value) use ($index, &$count, $total, &$result, $all) {
+                        $result[$index] = $value;
+                        $count++;
+                        if ($count >= $total) {
+                            $all->resolve($result);
+                        }
+                    },
+                    [$all, 'reject']
+                );
+            } else {
+                $result[$index] = $promiseOrValue;
+                $count++;
+            }
+        }
+        if ($count === $total) {
+            $all->resolve($result);
+        }
+        return new Promise($all, $this);
+    }
+
+    /**
+     * Synchronously wait when promise completes
+     *
+     * @param Promise $promise
+     * @return mixed
+     */
+    public function wait(Promise $promise)
+    {
+        $this->beforeWait($promise);
+        $dfdQueue = Deferred::getQueue();
+        $promiseQueue = SyncPromise::getQueue();
+
+        while (
+            $promise->adoptedPromise->state === SyncPromise::PENDING &&
+            !($dfdQueue->isEmpty() && $promiseQueue->isEmpty())
+        ) {
+            Deferred::runQueue();
+            SyncPromise::runQueue();
+            $this->onWait($promise);
+        }
+
+        /** @var SyncPromise $syncPromise */
+        $syncPromise = $promise->adoptedPromise;
+
+        if ($syncPromise->state === SyncPromise::FULFILLED) {
+            return $syncPromise->result;
+        } else if ($syncPromise->state === SyncPromise::REJECTED) {
+            throw $syncPromise->result;
+        }
+
+        throw new InvariantViolation("Could not resolve promise");
+    }
+
+    /**
+     * Execute just before starting to run promise completion
+     *
+     * @param Promise $promise
+     */
+    protected function beforeWait(Promise $promise)
+    {
+    }
+
+    /**
+     * Execute while running promise completion
+     *
+     * @param Promise $promise
+     */
+    protected function onWait(Promise $promise)
+    {
+    }
+}

system/3rd_party/graphql-php/Executor/Promise/Promise.php

@@ -0,0 +1,39 @@
+<?php
+namespace GraphQL\Executor\Promise;
+
+use GraphQL\Utils\Utils;
+
+/**
+ * Convenience wrapper for promises represented by Promise Adapter
+ */
+class Promise
+{
+    private $adapter;
+
+    public $adoptedPromise;
+
+    /**
+     * Promise constructor.
+     *
+     * @param mixed $adoptedPromise
+     * @param PromiseAdapter $adapter
+     */
+    public function __construct($adoptedPromise, PromiseAdapter $adapter)
+    {
+        Utils::invariant(!$adoptedPromise instanceof self, 'Expecting promise from adapted system, got ' . __CLASS__);
+
+        $this->adapter = $adapter;
+        $this->adoptedPromise = $adoptedPromise;
+    }
+
+    /**
+     * @param callable|null $onFulfilled
+     * @param callable|null $onRejected
+     *
+     * @return Promise
+     */
+    public function then(callable $onFulfilled = null, callable $onRejected = null)
+    {
+        return $this->adapter->then($this, $onFulfilled, $onRejected);
+    }
+}

system/3rd_party/graphql-php/Executor/Promise/PromiseAdapter.php

@@ -0,0 +1,80 @@
+<?php
+namespace GraphQL\Executor\Promise;
+
+/**
+ * Provides a means for integration of async PHP platforms ([related docs](data-fetching.md#async-php))
+ */
+interface PromiseAdapter
+{
+    /**
+     * Return true if the value is a promise or a deferred of the underlying platform
+     *
+     * @api
+     * @param mixed $value
+     * @return bool
+     */
+    public function isThenable($value);
+
+    /**
+     * Converts thenable of the underlying platform into GraphQL\Executor\Promise\Promise instance
+     *
+     * @api
+     * @param object $thenable
+     * @return Promise
+     */
+    public function convertThenable($thenable);
+
+    /**
+     * Accepts our Promise wrapper, extracts adopted promise out of it and executes actual `then` logic described
+     * in Promises/A+ specs. Then returns new wrapped instance of GraphQL\Executor\Promise\Promise.
+     *
+     * @api
+     * @param Promise $promise
+     * @param callable|null $onFulfilled
+     * @param callable|null $onRejected
+     *
+     * @return Promise
+     */
+    public function then(Promise $promise, callable $onFulfilled = null, callable $onRejected = null);
+
+    /**
+     * Creates a Promise
+     *
+     * Expected resolver signature:
+     *     function(callable $resolve, callable $reject)
+     *
+     * @api
+     * @param callable $resolver
+     * @return Promise
+     */
+    public function create(callable $resolver);
+
+    /**
+     * Creates a fulfilled Promise for a value if the value is not a promise.
+     *
+     * @api
+     * @param mixed $value
+     * @return Promise
+     */
+    public function createFulfilled($value = null);
+
+    /**
+     * Creates a rejected promise for a reason if the reason is not a promise. If
+     * the provided reason is a promise, then it is returned as-is.
+     *
+     * @api
+     * @param \Throwable $reason
+     * @return Promise
+     */
+    public function createRejected($reason);
+
+    /**
+     * Given an array of promises (or values), returns a promise that is fulfilled when all the
+     * items in the array are fulfilled.
+     *
+     * @api
+     * @param array $promisesOrValues Promises or values.
+     * @return Promise
+     */
+    public function all(array $promisesOrValues);
+}

system/3rd_party/graphql-php/Executor/Values.php

@@ -0,0 +1,385 @@
+<?php
+namespace GraphQL\Executor;
+
+
+use GraphQL\Error\Error;
+use GraphQL\Error\InvariantViolation;
+use GraphQL\Language\AST\ArgumentNode;
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\EnumValueDefinitionNode;
+use GraphQL\Language\AST\FieldDefinitionNode;
+use GraphQL\Language\AST\FieldNode;
+use GraphQL\Language\AST\FragmentSpreadNode;
+use GraphQL\Language\AST\InlineFragmentNode;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Language\AST\VariableNode;
+use GraphQL\Language\AST\VariableDefinitionNode;
+use GraphQL\Language\Printer;
+use GraphQL\Type\Schema;
+use GraphQL\Type\Definition\Directive;
+use GraphQL\Type\Definition\FieldDefinition;
+use GraphQL\Type\Definition\InputObjectType;
+use GraphQL\Type\Definition\InputType;
+use GraphQL\Type\Definition\LeafType;
+use GraphQL\Type\Definition\ListOfType;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Utils\AST;
+use GraphQL\Utils\TypeInfo;
+use GraphQL\Utils\Utils;
+use GraphQL\Validator\DocumentValidator;
+
+class Values
+{
+    /**
+     * Prepares an object map of variables of the correct type based on the provided
+     * variable definitions and arbitrary input. If the input cannot be coerced
+     * to match the variable definitions, a Error will be thrown.
+     *
+     * @param Schema $schema
+     * @param VariableDefinitionNode[] $definitionNodes
+     * @param array $inputs
+     * @return array
+     * @throws Error
+     */
+    public static function getVariableValues(Schema $schema, $definitionNodes, array $inputs)
+    {
+        $coercedValues = [];
+        foreach ($definitionNodes as $definitionNode) {
+            $varName = $definitionNode->variable->name->value;
+            $varType = TypeInfo::typeFromAST($schema, $definitionNode->type);
+
+            if (!Type::isInputType($varType)) {
+                throw new Error(
+                    'Variable "$'.$varName.'" expected value of type ' .
+                    '"' . Printer::doPrint($definitionNode->type) . '" which cannot be used as an input type.',
+                    [$definitionNode->type]
+                );
+            }
+
+            if (!array_key_exists($varName, $inputs)) {
+                $defaultValue = $definitionNode->defaultValue;
+                if ($defaultValue) {
+                    $coercedValues[$varName] = AST::valueFromAST($defaultValue, $varType);
+                }
+                if ($varType instanceof NonNull) {
+                    throw new Error(
+                        'Variable "$'.$varName .'" of required type ' .
+                        '"'. Utils::printSafe($varType) . '" was not provided.',
+                        [$definitionNode]
+                    );
+                }
+            } else {
+                $value = $inputs[$varName];
+                $errors = self::isValidPHPValue($value, $varType);
+                if (!empty($errors)) {
+                    $message = "\n" . implode("\n", $errors);
+                    throw new Error(
+                        'Variable "$' . $varName . '" got invalid value ' .
+                        json_encode($value) . '.' . $message,
+                        [$definitionNode]
+                    );
+                }
+
+                $coercedValue = self::coerceValue($varType, $value);
+                Utils::invariant($coercedValue !== Utils::undefined(), 'Should have reported error.');
+                $coercedValues[$varName] = $coercedValue;
+            }
+        }
+        return $coercedValues;
+    }
+
+    /**
+     * Prepares an object map of argument values given a list of argument
+     * definitions and list of argument AST nodes.
+     *
+     * @param FieldDefinition|Directive $def
+     * @param FieldNode|\GraphQL\Language\AST\DirectiveNode $node
+     * @param $variableValues
+     * @return array
+     * @throws Error
+     */
+    public static function getArgumentValues($def, $node, $variableValues = null)
+    {
+        $argDefs = $def->args;
+        $argNodes = $node->arguments;
+
+        if (!$argDefs || null === $argNodes) {
+            return [];
+        }
+
+        $coercedValues = [];
+        $undefined = Utils::undefined();
+
+        /** @var ArgumentNode[] $argNodeMap */
+        $argNodeMap = $argNodes ? Utils::keyMap($argNodes, function (ArgumentNode $arg) {
+            return $arg->name->value;
+        }) : [];
+
+        foreach ($argDefs as $argDef) {
+            $name = $argDef->name;
+            $argType = $argDef->getType();
+            $argumentNode = isset($argNodeMap[$name]) ? $argNodeMap[$name] : null;
+
+            if (!$argumentNode) {
+                if ($argDef->defaultValueExists()) {
+                    $coercedValues[$name] = $argDef->defaultValue;
+                } else if ($argType instanceof NonNull) {
+                    throw new Error(
+                        'Argument "' . $name . '" of required type ' .
+                        '"' . Utils::printSafe($argType) . '" was not provided.',
+                        [$node]
+                    );
+                }
+            } else if ($argumentNode->value instanceof VariableNode) {
+                $variableName = $argumentNode->value->name->value;
+
+                if ($variableValues && array_key_exists($variableName, $variableValues)) {
+                    // Note: this does not check that this variable value is correct.
+                    // This assumes that this query has been validated and the variable
+                    // usage here is of the correct type.
+                    $coercedValues[$name] = $variableValues[$variableName];
+                } else if ($argDef->defaultValueExists()) {
+                    $coercedValues[$name] = $argDef->defaultValue;
+                } else if ($argType instanceof NonNull) {
+                    throw new Error(
+                        'Argument "' . $name . '" of required type "' . Utils::printSafe($argType) . '" was ' .
+                        'provided the variable "$' . $variableName . '" which was not provided ' .
+                        'a runtime value.',
+                        [ $argumentNode->value ]
+                    );
+                }
+            } else {
+                $valueNode = $argumentNode->value;
+                $coercedValue = AST::valueFromAST($valueNode, $argType, $variableValues);
+                if ($coercedValue === $undefined) {
+                    $errors = DocumentValidator::isValidLiteralValue($argType, $valueNode);
+                    $message = !empty($errors) ? ("\n" . implode("\n", $errors)) : '';
+                    throw new Error(
+                        'Argument "' . $name . '" got invalid value ' . Printer::doPrint($valueNode) . '.' . $message,
+                        [ $argumentNode->value ]
+                    );
+                }
+                $coercedValues[$name] = $coercedValue;
+            }
+        }
+        return $coercedValues;
+    }
+
+    /**
+     * Prepares an object map of argument values given a directive definition
+     * and a AST node which may contain directives. Optionally also accepts a map
+     * of variable values.
+     *
+     * If the directive does not exist on the node, returns undefined.
+     *
+     * @param Directive $directiveDef
+     * @param FragmentSpreadNode | FieldNode | InlineFragmentNode | EnumValueDefinitionNode | FieldDefinitionNode $node
+     * @param array|null $variableValues
+     *
+     * @return array|null
+     */
+    public static function getDirectiveValues(Directive $directiveDef, $node, $variableValues = null)
+    {
+        if (isset($node->directives) && $node->directives instanceof NodeList) {
+            $directiveNode = Utils::find($node->directives, function(DirectiveNode $directive) use ($directiveDef) {
+                return $directive->name->value === $directiveDef->name;
+            });
+
+            if ($directiveNode) {
+                return self::getArgumentValues($directiveDef, $directiveNode, $variableValues);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * @deprecated as of 8.0 (Moved to \GraphQL\Utils\AST::valueFromAST)
+     *
+     * @param $valueNode
+     * @param InputType $type
+     * @param null $variables
+     * @return array|null|\stdClass
+     */
+    public static function valueFromAST($valueNode, InputType $type, $variables = null)
+    {
+        return AST::valueFromAST($valueNode, $type, $variables);
+    }
+
+    /**
+     * Given a PHP value and a GraphQL type, determine if the value will be
+     * accepted for that type. This is primarily useful for validating the
+     * runtime values of query variables.
+     *
+     * @param $value
+     * @param InputType $type
+     * @return array
+     */
+    public static function isValidPHPValue($value, InputType $type)
+    {
+        // A value must be provided if the type is non-null.
+        if ($type instanceof NonNull) {
+            if (null === $value) {
+                return ['Expected "' . Utils::printSafe($type) . '", found null.'];
+            }
+            return self::isValidPHPValue($value, $type->getWrappedType());
+        }
+
+        if (null === $value) {
+            return [];
+        }
+
+        // Lists accept a non-list value as a list of one.
+        if ($type instanceof ListOfType) {
+            $itemType = $type->getWrappedType();
+            if (is_array($value)) {
+                $tmp = [];
+                foreach ($value as $index => $item) {
+                    $errors = self::isValidPHPValue($item, $itemType);
+                    $tmp = array_merge($tmp, Utils::map($errors, function ($error) use ($index) {
+                        return "In element #$index: $error";
+                    }));
+                }
+                return $tmp;
+            }
+            return self::isValidPHPValue($value, $itemType);
+        }
+
+        // Input objects check each defined field.
+        if ($type instanceof InputObjectType) {
+            if (!is_object($value) && !is_array($value)) {
+                return ["Expected \"{$type->name}\", found not an object."];
+            }
+            $fields = $type->getFields();
+            $errors = [];
+
+            // Ensure every provided field is defined.
+            $props = is_object($value) ? get_object_vars($value) : $value;
+            foreach ($props as $providedField => $tmp) {
+                if (!isset($fields[$providedField])) {
+                    $errors[] = "In field \"{$providedField}\": Unknown field.";
+                }
+            }
+
+            // Ensure every defined field is valid.
+            foreach ($fields as $fieldName => $tmp) {
+                $newErrors = self::isValidPHPValue(isset($value[$fieldName]) ? $value[$fieldName] : null, $fields[$fieldName]->getType());
+                $errors = array_merge(
+                    $errors,
+                    Utils::map($newErrors, function ($error) use ($fieldName) {
+                        return "In field \"{$fieldName}\": {$error}";
+                    })
+                );
+            }
+            return $errors;
+        }
+
+        if ($type instanceof LeafType) {
+            try {
+                // Scalar/Enum input checks to ensure the type can parse the value to
+                // a non-null value.
+                $parseResult = $type->parseValue($value);
+                if (null === $parseResult && !$type->isValidValue($value)) {
+                    $v = Utils::printSafeJson($value);
+                    return [
+                        "Expected type \"{$type->name}\", found $v."
+                    ];
+                }
+                return [];
+            } catch (\Exception $e) {
+                return [
+                    "Expected type \"{$type->name}\", found " . Utils::printSafeJson($value) . ': ' .
+                    $e->getMessage()
+                ];
+            } catch (\Throwable $e) {
+                return [
+                    "Expected type \"{$type->name}\", found " . Utils::printSafeJson($value) . ': ' .
+                    $e->getMessage()
+                ];
+            }
+        }
+
+        throw new InvariantViolation('Must be input type');
+    }
+
+    /**
+     * Given a type and any value, return a runtime value coerced to match the type.
+     */
+    private static function coerceValue(Type $type, $value)
+    {
+        $undefined = Utils::undefined();
+        if ($value === $undefined) {
+            return $undefined;
+        }
+
+        if ($type instanceof NonNull) {
+            if ($value === null) {
+                // Intentionally return no value.
+                return $undefined;
+            }
+            return self::coerceValue($type->getWrappedType(), $value);
+        }
+
+        if (null === $value) {
+            return null;
+        }
+
+        if ($type instanceof ListOfType) {
+            $itemType = $type->getWrappedType();
+            if (is_array($value) || $value instanceof \Traversable) {
+                $coercedValues = [];
+                foreach ($value as $item) {
+                    $itemValue = self::coerceValue($itemType, $item);
+                    if ($undefined === $itemValue) {
+                        // Intentionally return no value.
+                        return $undefined;
+                    }
+                    $coercedValues[] = $itemValue;
+                }
+                return $coercedValues;
+            } else {
+                $coercedValue = self::coerceValue($itemType, $value);
+                if ($coercedValue === $undefined) {
+                    // Intentionally return no value.
+                    return $undefined;
+                }
+                return [$coercedValue];
+            }
+        }
+
+        if ($type instanceof InputObjectType) {
+            $coercedObj = [];
+            $fields = $type->getFields();
+            foreach ($fields as $fieldName => $field) {
+                if (!array_key_exists($fieldName, $value)) {
+                    if ($field->defaultValueExists()) {
+                        $coercedObj[$fieldName] = $field->defaultValue;
+                    } else if ($field->getType() instanceof NonNull) {
+                        // Intentionally return no value.
+                        return $undefined;
+                    }
+                    continue;
+                }
+                $fieldValue = self::coerceValue($field->getType(), $value[$fieldName]);
+                if ($fieldValue === $undefined) {
+                    // Intentionally return no value.
+                    return $undefined;
+                }
+                $coercedObj[$fieldName] = $fieldValue;
+            }
+            return $coercedObj;
+        }
+
+        if ($type instanceof LeafType) {
+            $parsed = $type->parseValue($value);
+            if (null === $parsed) {
+                // null or invalid values represent a failure to parse correctly,
+                // in which case no value is returned.
+                return $undefined;
+            }
+            return $parsed;
+        }
+
+        throw new InvariantViolation('Must be input type');
+    }
+}