digiaonline / graphql-php

src/Util/TypeHelper.php

Indentation +19 added lines, -19 removed lines

@@ -29,8 +29,8 @@ 
      * @return bool
      */
     public function isEqualType(
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         // Equivalent types are equal.
         if ($typeA === $typeB) {
@@ -62,9 +62,9 @@ 
      * @return bool
      */
     public function isTypeSubtypeOf(
-      SchemaInterface $schema,
-      TypeInterface $maybeSubtype,
-      TypeInterface $superType
+        SchemaInterface $schema,
+        TypeInterface $maybeSubtype,
+        TypeInterface $superType
     ): bool {
         // Equivalent type is a valid subtype.
         if ($maybeSubtype === $superType) {
@@ -75,7 +75,7 @@ 
         if ($superType instanceof NonNullType) {
             if ($maybeSubtype instanceof NonNullType) {
                 return $this->isTypeSubtypeOf($schema,
-                  $maybeSubtype->getOfType(), $superType->getOfType());
+                    $maybeSubtype->getOfType(), $superType->getOfType());
             }
             return false;
         }
@@ -83,14 +83,14 @@ 
         if ($maybeSubtype instanceof NonNullType) {
             // If superType is nullable, maybeSubType may be non-null or nullable.
             return $this->isTypeSubtypeOf($schema, $maybeSubtype->getOfType(),
-              $superType);
+                $superType);
         }
 
         // If superType type is a list, maybeSubType type must also be a list.
         if ($superType instanceof ListType) {
             if ($maybeSubtype instanceof ListType) {
                 return $this->isTypeSubtypeOf($schema,
-                  $maybeSubtype->getOfType(), $superType->getOfType());
+                    $maybeSubtype->getOfType(), $superType->getOfType());
             }
             return false;
         }
@@ -127,9 +127,9 @@ 
      * @return bool
      */
     public function doTypesOverlap(
-      SchemaInterface $schema,
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        SchemaInterface $schema,
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         // Equivalent types overlap
         if ($typeA === $typeB) {
@@ -141,9 +141,9 @@ 
                 // If both types are abstract, then determine if there is any intersection
                 // between possible concrete types of each.
                 return arraySome($schema->getPossibleTypes($typeA),
-                  function (TypeInterface $type) use ($schema, $typeB) {
-                      return $schema->isPossibleType($typeB, $type);
-                  });
+                    function (TypeInterface $type) use ($schema, $typeB) {
+                        return $schema->isPossibleType($typeB, $type);
+                    });
             }
 
             // Determine if the latter type is a possible concrete type of the former.
@@ -173,8 +173,8 @@ 
      * @return bool
      */
     public function compareTypes(
-      TypeInterface $typeA,
-      TypeInterface $typeB
+        TypeInterface $typeA,
+        TypeInterface $typeB
     ): bool {
         if ($typeA instanceof ListType) {
             return $typeB instanceof ListType
@@ -212,8 +212,8 @@ 
      * @throws InvalidTypeException
      */
     public function fromAST(
-      SchemaInterface $schema,
-      TypeNodeInterface $typeNode
+        SchemaInterface $schema,
+        TypeNodeInterface $typeNode
     ): ?TypeInterface
     {
         $innerType = null;
@@ -233,6 +233,6 @@ 
         }
 
         throw new InvalidTypeException(sprintf('Unexpected type kind: %s',
-          $typeNode->getKind()));
+            $typeNode->getKind()));
     }
 }

Spacing +1 added lines, -1 removed lines

@@ -141,7 +141,7 @@
                 // If both types are abstract, then determine if there is any intersection
                 // between possible concrete types of each.
                 return arraySome($schema->getPossibleTypes($typeA),
-                  function (TypeInterface $type) use ($schema, $typeB) {
+                  function(TypeInterface $type) use ($schema, $typeB) {
                       return $schema->isPossibleType($typeB, $type);
                   });
             }

src/Util/ValueHelper.php

Indentation +31 added lines, -31 removed lines

@@ -39,19 +39,19 @@ 
         }
 
         return arrayEvery($argumentsA,
-          function (ArgumentNode $argumentA) use ($argumentsB) {
-              $argumentB = find($argumentsB,
+            function (ArgumentNode $argumentA) use ($argumentsB) {
+                $argumentB = find($argumentsB,
                 function (ArgumentNode $argument) use ($argumentA) {
                     return $argument->getNameValue() === $argumentA->getNameValue();
                 });
 
-              if (null === $argumentB) {
-                  return false;
-              }
+                if (null === $argumentB) {
+                    return false;
+                }
 
-              return $this->compareValues($argumentA->getValue(),
+                return $this->compareValues($argumentA->getValue(),
                 $argumentB->getValue());
-          });
+            });
     }
 
     /**
@@ -95,8 +95,8 @@ 
      */
     public function fromAST(
       ?NodeInterface $node,
-      TypeInterface $type,
-      array $variables = []
+        TypeInterface $type,
+        array $variables = []
     ) {
         if (null === $node) {
             throw new ResolutionException('Node is not defined.');
@@ -116,7 +116,7 @@ 
 
             if (!isset($variables[$variableName])) {
                 throw new ResolutionException(
-                  \sprintf('Cannot resolve value for missing variable "%s".',
+                    \sprintf('Cannot resolve value for missing variable "%s".',
                     $variableName)
                 );
             }
@@ -157,9 +157,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveNonNullType(
-      NodeInterface $node,
-      NonNullType $type,
-      array $variables = []
+        NodeInterface $node,
+        NonNullType $type,
+        array $variables = []
     ) {
         if ($node instanceof NullValueNode) {
             throw new ResolutionException('Cannot resolve non-null values from null value node.');
@@ -178,9 +178,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveListType(
-      NodeInterface $node,
-      ListType $type,
-      array $variables = []
+        NodeInterface $node,
+        ListType $type,
+        array $variables = []
     ) {
         $itemType = $type->getOfType();
 
@@ -198,7 +198,7 @@ 
                     $resolvedValues[] = null;
                 } else {
                     $resolvedValues[] = $this->fromAST($value, $itemType,
-                      $variables);
+                        $variables);
                 }
             }
 
@@ -215,8 +215,8 @@ 
      * @return bool
      */
     protected function isMissingVariable(
-      ValueNodeInterface $node,
-      array $variables
+        ValueNodeInterface $node,
+        array $variables
     ): bool {
         return $node instanceof VariableNode && !isset($variables[$node->getNameValue()]);
     }
@@ -232,9 +232,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveInputObjectType(
-      NodeInterface $node,
-      InputObjectType $type,
-      array $variables = []
+        NodeInterface $node,
+        InputObjectType $type,
+        array $variables = []
     ) {
         if (!$node instanceof ObjectValueNode) {
             throw new ResolutionException('Input object values can only be resolved form object value nodes.');
@@ -244,9 +244,9 @@ 
 
         /** @var ObjectFieldNode[] $fieldNodes */
         $fieldNodes = keyMap($node->getFields(),
-          function (ObjectFieldNode $value) {
-              return $value->getNameValue();
-          });
+            function (ObjectFieldNode $value) {
+                return $value->getNameValue();
+            });
 
         foreach ($type->getFields() as $field) {
             $name = $field->getName();
@@ -263,7 +263,7 @@ 
             }
 
             $fieldValue = $this->fromAST($fieldNode->getValue(),
-              $field->getType(), $variables);
+                $field->getType(), $variables);
 
             $resolvedValues[$name] = $fieldValue;
         }
@@ -291,7 +291,7 @@ 
 
         if (null === $enumValue) {
             throw new ResolutionException(\sprintf('Cannot resolve enum value for missing value "%s".',
-              $name));
+                $name));
         }
 
         return $enumValue->getValue();
@@ -306,9 +306,9 @@ 
      * @throws ResolutionException
      */
     protected function resolveScalarType(
-      NodeInterface $node,
-      ScalarType $type,
-      array $variables = []
+        NodeInterface $node,
+        ScalarType $type,
+        array $variables = []
     ) {
         // Scalars fulfill parsing a literal value via parseLiteral().
         // Invalid values represent a failure to parse correctly, in which case
@@ -323,7 +323,7 @@ 
 
         if (null === $result) {
             throw new ResolutionException(\sprintf('Failed to parse literal for scalar type "%s".',
-              (string)$type));
+                (string)$type));
         }
 
         return $result;

Spacing +3 added lines, -3 removed lines

@@ -39,9 +39,9 @@ 
         }
 
         return arrayEvery($argumentsA,
-          function (ArgumentNode $argumentA) use ($argumentsB) {
+          function(ArgumentNode $argumentA) use ($argumentsB) {
               $argumentB = find($argumentsB,
-                function (ArgumentNode $argument) use ($argumentA) {
+                function(ArgumentNode $argument) use ($argumentA) {
                     return $argument->getNameValue() === $argumentA->getNameValue();
                 });
 
@@ -244,7 +244,7 @@ 
 
         /** @var ObjectFieldNode[] $fieldNodes */
         $fieldNodes = keyMap($node->getFields(),
-          function (ObjectFieldNode $value) {
+          function(ObjectFieldNode $value) {
               return $value->getNameValue();
           });
 

src/Util/NameHelper.php

Indentation +4 added lines, -4 removed lines

@@ -44,17 +44,17 @@
 
         if (\strlen($name) > 1 && $name{0} === '_' && $name{1} === '_') {
             return new ValidationException(
-              sprintf('Name "%s" must not begin with "__", which is reserved by GraphQL introspection.',
+                sprintf('Name "%s" must not begin with "__", which is reserved by GraphQL introspection.',
                 $name),
-              $node instanceof NodeInterface ? [$node] : null
+                $node instanceof NodeInterface ? [$node] : null
             );
         }
 
         if (preg_match("/^[_a-zA-Z][_a-zA-Z0-9]*$/", $name) === 0) {
             return new ValidationException(
-              sprintf('Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%s" does not.',
+                sprintf('Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%s" does not.',
                 $name),
-              $node instanceof NodeInterface ? [$node] : null
+                $node instanceof NodeInterface ? [$node] : null
             );
         }
 

src/Util/helpers.php

Indentation +12 added lines, -12 removed lines

@@ -49,12 +49,12 @@ 
  * @return bool
  */
 function isTypeSubtypeOf(
-  SchemaInterface $schema,
-  TypeInterface $maybeSubtype,
-  TypeInterface $superType
+    SchemaInterface $schema,
+    TypeInterface $maybeSubtype,
+    TypeInterface $superType
 ): bool {
     return GraphQL::make(TypeHelper::class)
-      ->isTypeSubtypeOf($schema, $maybeSubtype, $superType);
+        ->isTypeSubtypeOf($schema, $maybeSubtype, $superType);
 }
 
 /**
@@ -65,12 +65,12 @@ 
  * @return bool
  */
 function doTypesOverlap(
-  SchemaInterface $schema,
-  TypeInterface $typeA,
-  TypeInterface $typeB
+    SchemaInterface $schema,
+    TypeInterface $typeA,
+    TypeInterface $typeB
 ): bool {
     return GraphQL::make(TypeHelper::class)
-      ->doTypesOverlap($schema, $typeA, $typeB);
+        ->doTypesOverlap($schema, $typeA, $typeB);
 }
 
 /**
@@ -80,8 +80,8 @@ 
  * @return TypeInterface|null
  */
 function typeFromAST(
-  SchemaInterface $schema,
-  TypeNodeInterface $typeNode
+    SchemaInterface $schema,
+    TypeNodeInterface $typeNode
 ): ?TypeInterface
 {
     return GraphQL::make(TypeHelper::class)->fromAST($schema, $typeNode);
@@ -96,8 +96,8 @@ 
  */
 function valueFromAST(
   ?NodeInterface $node,
-  TypeInterface $type,
-  array $variables = []
+    TypeInterface $type,
+    array $variables = []
 ) {
     return GraphQL::make(ValueHelper::class)->fromAST($node, $type, $variables);
 }

src/Util/UtilityProvider.php

Indentation +6 added lines, -6 removed lines

@@ -11,9 +11,9 @@ 
      * @var array
      */
     protected $provides = [
-      NameHelper::class,
-      TypeHelper::class,
-      ValueHelper::class,
+        NameHelper::class,
+        TypeHelper::class,
+        ValueHelper::class,
     ];
 
     /**
@@ -22,10 +22,10 @@ 
     public function register()
     {
         $this->container->add(NameHelper::class, NameHelper::class,
-          true/* $shared */);
+            true/* $shared */);
         $this->container->add(TypeHelper::class, TypeHelper::class,
-          true/* $shared */);
+            true/* $shared */);
         $this->container->add(ValueHelper::class, ValueHelper::class,
-          true/* $shared */);
+            true/* $shared */);
     }
 }

src/Util/utils.php

Indentation +5 added lines, -5 removed lines

@@ -38,11 +38,11 @@ 
     return $count === 1
       ? $selected[0]
       : \array_reduce($selected, function ($list, $item) use ($count, &$index) {
-          $list .= ($index > 0 && $index < ($count - 1) ? ', ' : '') . ($index === ($count - 1) ? ' or ' : '') .
+            $list .= ($index > 0 && $index < ($count - 1) ? ', ' : '') . ($index === ($count - 1) ? ' or ' : '') .
             $item;
-          $index++;
-          return $list;
-      }, '');
+            $index++;
+            return $list;
+        }, '');
 }
 
 /**
@@ -64,7 +64,7 @@ 
     for ($i = 0; $i < $oLength; $i++) {
         // Comparison must be case-insenstive.
         $distance = \levenshtein(\strtolower($input),
-          \strtolower($options[$i]));
+            \strtolower($options[$i]));
         $threshold = \max($inputThreshold, \strlen($options[$i]) / 2, 1);
         if ($distance <= $threshold) {
             $optionsByDistance[$options[$i]] = $distance;

Spacing +7 added lines, -7 removed lines

@@ -37,7 +37,7 @@ 
 
     return $count === 1
       ? $selected[0]
-      : \array_reduce($selected, function ($list, $item) use ($count, &$index) {
+      : \array_reduce($selected, function($list, $item) use ($count, &$index) {
           $list .= ($index > 0 && $index < ($count - 1) ? ', ' : '') . ($index === ($count - 1) ? ' or ' : '') .
             $item;
           $index++;
@@ -73,7 +73,7 @@ 
 
     $result = \array_keys($optionsByDistance);
 
-    \usort($result, function ($a, $b) use ($optionsByDistance) {
+    \usort($result, function($a, $b) use ($optionsByDistance) {
         return $optionsByDistance[$a] - $optionsByDistance[$b];
     });
 
@@ -89,7 +89,7 @@ 
  */
 function quotedOrList(array $items): string
 {
-    return orList(array_map(function ($item) {
+    return orList(array_map(function($item) {
         return '"' . $item . '"';
     }, $items));
 }
@@ -103,7 +103,7 @@ 
  */
 function arrayEvery(array $array, callable $fn): bool
 {
-    return array_reduce($array, function ($result, $value) use ($fn) {
+    return array_reduce($array, function($result, $value) use ($fn) {
         return $result && $fn($value);
     }, true);
 }
@@ -116,7 +116,7 @@ 
  */
 function arraySome(array $array, callable $fn)
 {
-    return array_reduce($array, function ($result, $value) use ($fn) {
+    return array_reduce($array, function($result, $value) use ($fn) {
         return $result || $fn($value);
     });
 }
@@ -146,7 +146,7 @@ 
  */
 function keyMap(array $array, callable $keyFn): array
 {
-    return array_reduce($array, function ($map, $item) use ($keyFn) {
+    return array_reduce($array, function($map, $item) use ($keyFn) {
         $map[$keyFn($item)] = $item;
         return $map;
     }, []);
@@ -161,7 +161,7 @@ 
  */
 function keyValueMap(array $array, callable $keyFn, callable $valFn): array
 {
-    return array_reduce($array, function ($map, $item) use ($keyFn, $valFn) {
+    return array_reduce($array, function($map, $item) use ($keyFn, $valFn) {
         $map[$keyFn($item)] = $valFn($item);
         return $map;
     }, []);

src/Execution/ExecutionContext.php

Indentation +9 added lines, -9 removed lines

@@ -63,14 +63,14 @@ 
      * @param array $errors
      */
     public function __construct(
-      Schema $schema,
-      array $fragments,
-      $rootValue,
-      $contextValue,
-      $variableValues,
-      $fieldResolver,
-      OperationDefinitionNode $operation,
-      array $errors
+        Schema $schema,
+        array $fragments,
+        $rootValue,
+        $contextValue,
+        $variableValues,
+        $fieldResolver,
+        OperationDefinitionNode $operation,
+        array $errors
     ) {
         $this->schema = $schema;
         $this->fragments = $fragments;
@@ -192,7 +192,7 @@ 
     {
         //We can probably return different strategy in the future e.g:AsyncExecutionStrategy
         return new ExecutorExecutionStrategy($this, $this->operation,
-          $this->rootValue);
+            $this->rootValue);
     }
 
     /**

src/Execution/ExecutionContextBuilder.php

Indentation +22 added lines, -22 removed lines

@@ -30,13 +30,13 @@ 
      * @throws \Exception
      */
     public function buildContext(
-      Schema $schema,
-      DocumentNode $documentNode,
-      $rootValue,
-      $contextValue,
-      $rawVariableValues,
-      $operationName = null,
-      callable $fieldResolver = null
+        Schema $schema,
+        DocumentNode $documentNode,
+        $rootValue,
+        $contextValue,
+        $rawVariableValues,
+        $operationName = null,
+        callable $fieldResolver = null
     ): ExecutionContext {
         //@TODO validate $rawVariableValues?
 
@@ -49,19 +49,19 @@ 
                 case NodeKindEnum::OPERATION_DEFINITION:
                     if (!$operationName && $operation) {
                         throw new ExecutionException(
-                          'Must provide operation name if query contains multiple operations.'
+                            'Must provide operation name if query contains multiple operations.'
                         );
                     }
 
                     if (!$operationName || (!empty($definition->getName()) && $definition->getName()
-                          ->getValue() === $operationName)) {
+                            ->getValue() === $operationName)) {
                         $operation = $definition;
                     }
                     break;
                 case NodeKindEnum::FRAGMENT_DEFINITION:
                 case NodeKindEnum::FRAGMENT_SPREAD:
                     $fragments[$definition->getName()
-                      ->getValue()] = $definition;
+                        ->getValue()] = $definition;
                     break;
             }
         }
@@ -69,7 +69,7 @@ 
         if (null === $operation) {
             if ($operationName !== null) {
                 throw new ExecutionException(sprintf('Unknown operation named "%s".',
-                  $operationName));
+                    $operationName));
             }
 
             throw new ExecutionException('Must provide an operation.');
@@ -80,9 +80,9 @@ 
         /** @var OperationDefinitionNode $operation */
         if ($operation) {
             $coercedVariableValues = coerceVariableValues(
-              $schema,
-              $operation->getVariableDefinitions(),
-              $rawVariableValues
+                $schema,
+                $operation->getVariableDefinitions(),
+                $rawVariableValues
             );
 
             $variableValues = $coercedVariableValues->getValue();
@@ -93,14 +93,14 @@ 
         }
 
         $executionContext = new ExecutionContext(
-          $schema,
-          $fragments,
-          $rootValue,
-          $contextValue,
-          $variableValues,
-          $fieldResolver,
-          $operation,
-          $errors
+            $schema,
+            $fragments,
+            $rootValue,
+            $contextValue,
+            $variableValues,
+            $fieldResolver,
+            $operation,
+            $errors
         );
 
         return $executionContext;

src/Execution/ValuesHelper.php

Indentation +108 added lines, -108 removed lines

@@ -50,9 +50,9 @@ 
      * @throws InvariantException
      */
     public function coerceDirectiveValues(
-      Directive $directive,
-      $node,
-      array $variableValues = []
+        Directive $directive,
+        $node,
+        array $variableValues = []
     ): ?array
     {
         $directiveNode = $node->hasDirectives()
@@ -63,7 +63,7 @@ 
 
         if (null !== $directiveNode) {
             return $this->coerceArgumentValues($directive, $directiveNode,
-              $variableValues);
+                $variableValues);
         }
 
         return null;
@@ -85,9 +85,9 @@ 
      * @throws InvariantException
      */
     public function coerceArgumentValues(
-      $definition,
-      ArgumentsAwareInterface $node,
-      array $variableValues = []
+        $definition,
+        ArgumentsAwareInterface $node,
+        array $variableValues = []
     ): array {
         $coercedValues = [];
         $argumentDefinitions = $definition->getArguments();
@@ -98,9 +98,9 @@ 
         }
 
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $value) {
-              return $value->getNameValue();
-          });
+            function (ArgumentNode $value) {
+                return $value->getNameValue();
+            });
 
         foreach ($argumentDefinitions as $argumentDefinition) {
             $argumentName = $argumentDefinition->getName();
@@ -114,36 +114,36 @@ 
                     $coercedValues[$argumentName] = $defaultValue;
                 } elseif ($argumentType instanceof NonNullType) {
                     throw new ExecutionException(
-                      sprintf('Argument "%s" of required type "%s" was not provided.',
+                        sprintf('Argument "%s" of required type "%s" was not provided.',
                         $argumentName,
                         $argumentType),
-                      [$node]
+                        [$node]
                     );
                 }
             } elseif ($argumentNode->getValue() instanceof VariableNode) {
                 $coercedValues[$argumentName] = $this->coerceValueForVariableNode(
-                  $argumentNode->getValue(),
-                  $argumentType,
-                  $argumentName,
-                  $variableValues,
-                  $defaultValue
+                    $argumentNode->getValue(),
+                    $argumentType,
+                    $argumentName,
+                    $variableValues,
+                    $defaultValue
                 );
             } else {
                 $coercedValue = null;
 
                 try {
                     $coercedValue = valueFromAST($argumentNode->getValue(),
-                      $argumentType, $variableValues);
+                        $argumentType, $variableValues);
                 } catch (\Exception $ex) {
                     // Value nodes that cannot be resolved should be treated as invalid values
                     // because there is no undefined value in PHP so that we throw an exception
 
                     throw new ExecutionException(
-                      sprintf('Argument "%s" has invalid value %s.',
+                        sprintf('Argument "%s" has invalid value %s.',
                         $argumentName,
                         (string)$argumentNode->getValue()),
-                      [$argumentNode->getValue()],
-                      null, null, null, $ex
+                        [$argumentNode->getValue()],
+                        null, null, null, $ex
                     );
                 }
 
@@ -165,11 +165,11 @@ 
      * @throws ExecutionException
      */
     protected function coerceValueForVariableNode(
-      VariableNode $variableNode,
-      TypeInterface $argumentType,
-      string $argumentName,
-      array $variableValues,
-      $defaultValue
+        VariableNode $variableNode,
+        TypeInterface $argumentType,
+        string $argumentName,
+        array $variableValues,
+        $defaultValue
     ) {
         $variableName = $variableNode->getNameValue();
 
@@ -186,13 +186,13 @@ 
 
         if ($argumentType instanceof NonNullType) {
             throw new ExecutionException(
-              \sprintf(
+                \sprintf(
                 'Argument "%s" of required type "%s" was provided the variable "$%s" which was not provided a runtime value.',
                 $argumentName,
                 $argumentType,
                 $variableName
-              ),
-              [$variableNode]
+                ),
+                [$variableNode]
             );
         }
     }
@@ -210,18 +210,18 @@ 
      * @throws \Exception
      */
     public function coerceVariableValues(
-      Schema $schema,
-      array $variableDefinitionNodes,
-      array $inputs
+        Schema $schema,
+        array $variableDefinitionNodes,
+        array $inputs
     ): CoercedValue {
         $coercedValues = [];
         $errors = [];
 
         foreach ($variableDefinitionNodes as $variableDefinitionNode) {
             $variableName = $variableDefinitionNode->getVariable()
-              ->getNameValue();
+                ->getNameValue();
             $variableType = typeFromAST($schema,
-              $variableDefinitionNode->getType());
+                $variableDefinitionNode->getType());
 
             if (!$this->isInputType($variableType)) {
                 $variableTypeName = (string)$variableType;
@@ -231,48 +231,48 @@ 
                 }
 
                 $errors[] = $this->buildCoerceException(
-                  sprintf(
+                    sprintf(
                     'Variable "$%s" expected value of type "%s" which cannot be used as an input type',
                     $variableName,
                     $variableTypeName
-                  ),
-                  $variableDefinitionNode,
-                  null
+                    ),
+                    $variableDefinitionNode,
+                    null
                 );
             } else {
                 if (!array_key_exists($variableName, $inputs)) {
                     if ($variableType instanceof NonNullType) {
                         $errors[] = $this->buildCoerceException(
-                          sprintf(
+                            sprintf(
                             'Variable "$%s" of required type "%s" was not provided',
                             $variableName,
                             (string)$variableType
-                          ),
-                          $variableDefinitionNode,
-                          null
+                            ),
+                            $variableDefinitionNode,
+                            null
                         );
                     } elseif ($variableDefinitionNode->getDefaultValue() !== null) {
                         $coercedValues[$variableName] = valueFromAST(
-                          $variableDefinitionNode->getDefaultValue(),
-                          $variableType
+                            $variableDefinitionNode->getDefaultValue(),
+                            $variableType
                         );
                     }
                 } else {
                     $value = $inputs[$variableName];
                     $coercedValue = $this->coerceValue($value, $variableType,
-                      $variableDefinitionNode);
+                        $variableDefinitionNode);
                     if ($coercedValue->hasErrors()) {
                         $messagePrelude = sprintf(
-                          'Variable "$%s" got invalid value %s',
-                          $variableName, json_encode($value)
+                            'Variable "$%s" got invalid value %s',
+                            $variableName, json_encode($value)
                         );
                         foreach ($coercedValue->getErrors() as $error) {
                             $errors[] = $this->buildCoerceException(
-                              $messagePrelude,
-                              $variableDefinitionNode,
-                              null,
-                              $error->getMessage(),
-                              $error
+                                $messagePrelude,
+                                $variableDefinitionNode,
+                                null,
+                                $error->getMessage(),
+                                $error
                             );
                         }
                     } else {
@@ -308,8 +308,8 @@ 
      * @return GraphQLException
      */
     protected function buildCoerceException(
-      string $message,
-      NodeInterface $blameNode,
+        string $message,
+        NodeInterface $blameNode,
       ?Path $path,
       ?string $subMessage = null,
       ?GraphQLException $originalException = null
@@ -317,14 +317,14 @@ 
         $stringPath = $this->printPath($path);
 
         return new CoercingException(
-          $message .
-          (($stringPath !== '') ? ' at ' . $stringPath : $stringPath) .
-          (($subMessage !== null) ? '; ' . $subMessage : '.'),
-          [$blameNode],
-          null,
-          null,
-          [],
-          $originalException
+            $message .
+            (($stringPath !== '') ? ' at ' . $stringPath : $stringPath) .
+            (($subMessage !== null) ? '; ' . $subMessage : '.'),
+            [$blameNode],
+            null,
+            null,
+            [],
+            $originalException
         );
     }
 
@@ -365,14 +365,14 @@ 
      * @throws GraphQLException
      */
     private function coerceValue(
-      $value,
-      $type,
-      $blameNode,
+        $value,
+        $type,
+        $blameNode,
       ?Path $path = null
     ): CoercedValue {
         if ($type instanceof NonNullType) {
             return $this->coerceValueForNonNullType($value, $type, $blameNode,
-              $path);
+                $path);
         }
 
         if (empty($value)) {
@@ -381,22 +381,22 @@ 
 
         if ($type instanceof ScalarType) {
             return $this->coerceValueForScalarType($value, $type, $blameNode,
-              $path);
+                $path);
         }
 
         if ($type instanceof EnumType) {
             return $this->coerceValueForEnumType($value, $type, $blameNode,
-              $path);
+                $path);
         }
 
         if ($type instanceof ListType) {
             return $this->coerceValueForListType($value, $type, $blameNode,
-              $path);
+                $path);
         }
 
         if ($type instanceof InputObjectType) {
             return $this->coerceValueForInputObjectType($value, $type,
-              $blameNode, $path);
+                $blameNode, $path);
         }
 
         throw new GraphQLException('Unexpected type.');
@@ -413,23 +413,23 @@ 
      * @throws InvariantException
      */
     protected function coerceValueForNonNullType(
-      $value,
-      NonNullType $type,
-      NodeInterface $blameNode,
+        $value,
+        NonNullType $type,
+        NodeInterface $blameNode,
       ?Path $path
     ): CoercedValue {
         if (empty($value)) {
             return new CoercedValue(null, [
-              $this->buildCoerceException(
+                $this->buildCoerceException(
                 sprintf('Expected non-nullable type %s not to be null',
-                  (string)$type),
+                    (string)$type),
                 $blameNode,
                 $path
-              ),
+                ),
             ]);
         }
         return $this->coerceValue($value, $type->getOfType(), $blameNode,
-          $path);
+            $path);
     }
 
     /**
@@ -445,29 +445,29 @@ 
      * @return CoercedValue
      */
     protected function coerceValueForScalarType(
-      $value,
-      ScalarType $type,
-      NodeInterface $blameNode,
+        $value,
+        ScalarType $type,
+        NodeInterface $blameNode,
       ?Path $path
     ): CoercedValue {
         try {
             $parseResult = $type->parseValue($value);
             if (empty($parseResult)) {
                 return new CoercedValue(null, [
-                  new GraphQLException(sprintf('Expected type %s',
+                    new GraphQLException(sprintf('Expected type %s',
                     (string)$type)),
                 ]);
             }
             return new CoercedValue($parseResult, null);
         } catch (InvalidTypeException|CoercingException $ex) {
             return new CoercedValue(null, [
-              $this->buildCoerceException(
+                $this->buildCoerceException(
                 sprintf('Expected type %s', (string)$type),
                 $blameNode,
                 $path,
                 $ex->getMessage(),
                 $ex
-              ),
+                ),
             ]);
         }
     }
@@ -482,9 +482,9 @@ 
      * @throws InvariantException
      */
     protected function coerceValueForEnumType(
-      $value,
-      EnumType $type,
-      NodeInterface $blameNode,
+        $value,
+        EnumType $type,
+        NodeInterface $blameNode,
       ?Path $path
     ): CoercedValue {
         if (is_string($value)) {
@@ -495,16 +495,16 @@ 
         }
 
         $suggestions = suggestionList((string)$value,
-          array_map(function (EnumValue $enumValue) {
-              return $enumValue->getName();
-          }, $type->getValues()));
+            array_map(function (EnumValue $enumValue) {
+                return $enumValue->getName();
+            }, $type->getValues()));
 
         $didYouMean = (!empty($suggestions))
           ? 'did you mean' . implode(',', $suggestions)
           : null;
 
         return new CoercedValue(null, [
-          $this->buildCoerceException(sprintf('Expected type %s',
+            $this->buildCoerceException(sprintf('Expected type %s',
             $type->getName()), $blameNode, $path, $didYouMean),
         ]);
     }
@@ -518,9 +518,9 @@ 
      * @throws InvariantException
      */
     protected function coerceValueForListType(
-      $value,
-      ListType $type,
-      NodeInterface $blameNode,
+        $value,
+        ListType $type,
+        NodeInterface $blameNode,
       ?Path $path
     ): CoercedValue {
         $itemType = $type->getOfType();
@@ -530,7 +530,7 @@ 
             $coercedValues = [];
             foreach ($value as $index => $itemValue) {
                 $coercedValue = $this->coerceValue($itemValue, $itemType,
-                  $blameNode, new Path($path, $index));
+                    $blameNode, new Path($path, $index));
 
                 if ($coercedValue->hasErrors()) {
                     $errors = array_merge($errors, $coercedValue->getErrors());
@@ -546,7 +546,7 @@ 
         $coercedValue = $this->coerceValue($value, $itemType, $blameNode);
 
         return new CoercedValue([$coercedValue->getValue()],
-          $coercedValue->getErrors());
+            $coercedValue->getErrors());
     }
 
     /**
@@ -560,9 +560,9 @@ 
      * @throws InvariantException
      */
     protected function coerceValueForInputObjectType(
-      $value,
-      InputObjectType $type,
-      NodeInterface $blameNode,
+        $value,
+        InputObjectType $type,
+        NodeInterface $blameNode,
       ?Path $path
     ): CoercedValue {
         $errors = [];
@@ -576,20 +576,20 @@ 
                     $coercedValue[$field->getName()] = $field->getDefaultValue();
                 } elseif ($field->getType() instanceof NonNullType) {
                     $errors[] = new GraphQLException(
-                      sprintf(
+                        sprintf(
                         "Field %s of required type %s! was not provided.",
                         $this->printPath(new Path($path, $field->getName())),
                         $field->getType()->getOfType()
-                      )
+                        )
                     );
                 }
             } else {
                 $fieldValue = $value[$field->getName()];
                 $coercedValue = $this->coerceValue(
-                  $fieldValue,
-                  $field->getType(),
-                  $blameNode,
-                  new Path($path, $field->getName())
+                    $fieldValue,
+                    $field->getType(),
+                    $blameNode,
+                    new Path($path, $field->getName())
                 );
 
                 if ($coercedValue->hasErrors()) {
@@ -609,11 +609,11 @@ 
                   : null;
 
                 $errors[] = $this->buildCoerceException(
-                  sprintf('Field "%s" is not defined by type %s', $fieldName,
+                    sprintf('Field "%s" is not defined by type %s', $fieldName,
                     $type->getName()),
-                  $blameNode,
-                  $path,
-                  $didYouMean
+                    $blameNode,
+                    $path,
+                    $didYouMean
                 );
             }
         }

Spacing +4 added lines, -4 removed lines

@@ -57,7 +57,7 @@ 
     {
         $directiveNode = $node->hasDirectives()
           ? find($node->getDirectives(),
-            function (NameAwareInterface $value) use ($directive) {
+            function(NameAwareInterface $value) use ($directive) {
                 return $value->getNameValue() === $directive->getName();
             }) : null;
 
@@ -98,7 +98,7 @@ 
         }
 
         $argumentNodeMap = keyMap($argumentNodes,
-          function (ArgumentNode $value) {
+          function(ArgumentNode $value) {
               return $value->getNameValue();
           });
 
@@ -459,7 +459,7 @@ 
                 ]);
             }
             return new CoercedValue($parseResult, null);
-        } catch (InvalidTypeException|CoercingException $ex) {
+        } catch (InvalidTypeException | CoercingException $ex) {
             return new CoercedValue(null, [
               $this->buildCoerceException(
                 sprintf('Expected type %s', (string)$type),
@@ -495,7 +495,7 @@ 
         }
 
         $suggestions = suggestionList((string)$value,
-          array_map(function (EnumValue $enumValue) {
+          array_map(function(EnumValue $enumValue) {
               return $enumValue->getName();
           }, $type->getValues()));