digiaonline / graphql-php

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()));
 

src/Execution/values.php

Indentation +12 added lines, -12 removed lines

@@ -18,12 +18,12 @@ 
  * @return array
  */
 function coerceVariableValues(
-  SchemaInterface $schema,
-  array $nodes,
-  array $inputs
+    SchemaInterface $schema,
+    array $nodes,
+    array $inputs
 ): CoercedValue {
     return GraphQL::make(ValuesHelper::class)
-      ->coerceVariableValues($schema, $nodes, $inputs);
+        ->coerceVariableValues($schema, $nodes, $inputs);
 }
 
 /**
@@ -34,12 +34,12 @@ 
  * @return array
  */
 function coerceArgumentValues(
-  $definition,
-  ArgumentsAwareInterface $node,
-  array $variableValues = []
+    $definition,
+    ArgumentsAwareInterface $node,
+    array $variableValues = []
 ): array {
     return GraphQL::make(ValuesHelper::class)
-      ->coerceArgumentValues($definition, $node, $variableValues);
+        ->coerceArgumentValues($definition, $node, $variableValues);
 }
 
 /**
@@ -50,11 +50,11 @@ 
  * @return array|null
  */
 function coerceDirectiveValues(
-  Directive $directive,
-  $node,
-  array $variableValues = []
+    Directive $directive,
+    $node,
+    array $variableValues = []
 ): ?array
 {
     return GraphQL::make(ValuesHelper::class)
-      ->coerceDirectiveValues($directive, $node, $variableValues);
+        ->coerceDirectiveValues($directive, $node, $variableValues);
 }

src/Execution/ResolveInfo.php

Indentation +8 added lines, -8 removed lines

@@ -77,16 +77,16 @@
      * @param array $variableValues
      */
     public function __construct(
-      string $fieldName,
+        string $fieldName,
       ?array $fieldNodes,
-      TypeInterface $returnType,
-      ObjectType $parentType,
+        TypeInterface $returnType,
+        ObjectType $parentType,
       ?array $path,
-      SchemaInterface $schema,
-      array $fragments,
-      $rootValue,
-      OperationDefinitionNode $operation,
-      array $variableValues
+        SchemaInterface $schema,
+        array $fragments,
+        $rootValue,
+        OperationDefinitionNode $operation,
+        array $variableValues
     ) {
         $this->fieldName = $fieldName;
         $this->fieldNodes = $fieldNodes;

src/Execution/ExecutionStrategy.php

Indentation +244 added lines, -244 removed lines

@@ -43,8 +43,8 @@ 
      * @var array
      */
     protected static $defaultFieldResolver = [
-      __CLASS__,
-      'defaultFieldResolver',
+        __CLASS__,
+        'defaultFieldResolver',
     ];
 
     /**
@@ -75,9 +75,9 @@ 
      * @param OperationDefinitionNode $operation
      */
     public function __construct(
-      ExecutionContext $context,
-      OperationDefinitionNode $operation,
-      $rootValue
+        ExecutionContext $context,
+        OperationDefinitionNode $operation,
+        $rootValue
     ) {
         $this->context = $context;
         $this->operation = $operation;
@@ -95,10 +95,10 @@ 
      * @return mixed|null
      */
     public static function defaultFieldResolver(
-      $rootValue,
-      $args,
-      $context,
-      ResolveInfo $info
+        $rootValue,
+        $args,
+        $context,
+        ResolveInfo $info
     ) {
         $fieldName = $info->getFieldName();
         $property = null;
@@ -118,7 +118,7 @@ 
 
 
         return $property instanceof \Closure ? $property($rootValue, $args,
-          $context, $info) : $property;
+            $context, $info) : $property;
     }
 
     /**
@@ -142,10 +142,10 @@ 
      * @throws \Throwable
      */
     public function executeFieldsSerially(
-      ObjectType $objectType,
-      $rootValue,
-      $path,
-      $fields
+        ObjectType $objectType,
+        $rootValue,
+        $path,
+        $fields
     ) {
 
         $finalResults = [];
@@ -153,18 +153,18 @@ 
         $promise = new \React\Promise\FulfilledPromise([]);
 
         $resolve = function (
-          $results,
-          $fieldName,
-          $path,
-          $objectType,
-          $rootValue,
-          $fieldNodes
+            $results,
+            $fieldName,
+            $path,
+            $objectType,
+            $rootValue,
+            $fieldNodes
         ) {
             $fieldPath = $path;
             $fieldPath[] = $fieldName;
             try {
                 $result = $this->resolveField($objectType, $rootValue,
-                  $fieldNodes, $fieldPath);
+                    $fieldNodes, $fieldPath);
             } catch (UndefinedException $ex) {
                 return null;
             }
@@ -172,8 +172,8 @@ 
             if ($this->isPromise($result)) {
                 /** @var ExtendedPromiseInterface $result */
                 return $result->then(function ($resolvedResult) use (
-                  $fieldName,
-                  $results
+                    $fieldName,
+                    $results
                 ) {
                     $results[$fieldName] = $resolvedResult;
                     return $results;
@@ -187,15 +187,15 @@ 
 
         foreach ($fields as $fieldName => $fieldNodes) {
             $promise = $promise->then(function ($resolvedResults) use (
-              $resolve,
-              $fieldName,
-              $path,
-              $objectType,
-              $rootValue,
-              $fieldNodes
+                $resolve,
+                $fieldName,
+                $path,
+                $objectType,
+                $rootValue,
+                $fieldNodes
             ) {
                 return $resolve($resolvedResults, $fieldName, $path,
-                  $objectType, $rootValue, $fieldNodes);
+                    $objectType, $rootValue, $fieldNodes);
             });
         }
 
@@ -222,10 +222,10 @@ 
      * @throws \Throwable
      */
     protected function executeFields(
-      ObjectType $objectType,
-      $rootValue,
-      $path,
-      $fields
+        ObjectType $objectType,
+        $rootValue,
+        $path,
+        $fields
     ): array {
         $finalResults = [];
         $isContainsPromise = false;
@@ -236,7 +236,7 @@ 
 
             try {
                 $result = $this->resolveField($objectType, $rootValue,
-                  $fieldNodes, $fieldPath);
+                    $fieldNodes, $fieldPath);
             } catch (UndefinedException $ex) {
                 continue;
             }
@@ -272,42 +272,42 @@ 
      * @throws \Throwable
      */
     protected function resolveField(
-      ObjectType $parentType,
-      $rootValue,
-      $fieldNodes,
-      $path
+        ObjectType $parentType,
+        $rootValue,
+        $fieldNodes,
+        $path
     ) {
         /** @var FieldNode $fieldNode */
         $fieldNode = $fieldNodes[0];
 
         $field = $this->getFieldDefinition($this->context->getSchema(),
-          $parentType, $fieldNode->getNameValue());
+            $parentType, $fieldNode->getNameValue());
 
         if (null === $field) {
             throw new UndefinedException('Undefined field definition.');
         }
 
         $info = $this->buildResolveInfo($fieldNodes, $fieldNode, $field,
-          $parentType, $path, $this->context);
+            $parentType, $path, $this->context);
 
         $resolveFunction = $this->determineResolveFunction($field, $parentType,
-          $this->context);
+            $this->context);
 
         $result = $this->resolveFieldValueOrError(
-          $field,
-          $fieldNode,
-          $resolveFunction,
-          $rootValue,
-          $this->context,
-          $info
+            $field,
+            $fieldNode,
+            $resolveFunction,
+            $rootValue,
+            $this->context,
+            $info
         );
 
         $result = $this->completeValueCatchingError(
-          $field->getType(),
-          $fieldNodes,
-          $info,
-          $path,
-          $result// $result is passed as $source
+            $field->getType(),
+            $fieldNodes,
+            $info,
+            $path,
+            $result// $result is passed as $source
         );
 
         return $result;
@@ -323,9 +323,9 @@ 
      * @throws \Digia\GraphQL\Error\InvariantException
      */
     public function getFieldDefinition(
-      Schema $schema,
-      ObjectType $parentType,
-      string $fieldName
+        Schema $schema,
+        ObjectType $parentType,
+        string $fieldName
     ) {
         $schemaMetaFieldDefinition = SchemaMetaFieldDefinition();
         $typeMetaFieldDefinition = TypeMetaFieldDefinition();
@@ -359,24 +359,24 @@ 
      * @return ResolveInfo
      */
     private function buildResolveInfo(
-      array $fieldNodes,
-      FieldNode $fieldNode,
-      Field $field,
-      ObjectType $parentType,
+        array $fieldNodes,
+        FieldNode $fieldNode,
+        Field $field,
+        ObjectType $parentType,
       ?array $path,
-      ExecutionContext $context
+        ExecutionContext $context
     ) {
         return new ResolveInfo(
-          $fieldNode->getNameValue(),
-          $fieldNodes,
-          $field->getType(),
-          $parentType,
-          $path,
-          $context->getSchema(),
-          $context->getFragments(),
-          $context->getRootValue(),
-          $context->getOperation(),
-          $context->getVariableValues()
+            $fieldNode->getNameValue(),
+            $fieldNodes,
+            $field->getType(),
+            $parentType,
+            $path,
+            $context->getSchema(),
+            $context->getFragments(),
+            $context->getRootValue(),
+            $context->getOperation(),
+            $context->getVariableValues()
         );
     }
 
@@ -388,9 +388,9 @@ 
      * @return callable|mixed|null
      */
     private function determineResolveFunction(
-      Field $field,
-      ObjectType $objectType,
-      ExecutionContext $context
+        Field $field,
+        ObjectType $objectType,
+        ExecutionContext $context
     ) {
 
         if ($field->hasResolve()) {
@@ -415,19 +415,19 @@ 
      * @return array|\Throwable
      */
     private function resolveFieldValueOrError(
-      Field $field,
-      FieldNode $fieldNode,
+        Field $field,
+        FieldNode $fieldNode,
       ?callable $resolveFunction,
-      $rootValue,
-      ExecutionContext $context,
-      ResolveInfo $info
+        $rootValue,
+        ExecutionContext $context,
+        ResolveInfo $info
     ) {
         try {
             $args = coerceArgumentValues($field, $fieldNode,
-              $context->getVariableValues());
+                $context->getVariableValues());
 
             return $resolveFunction($rootValue, $args,
-              $context->getContextValue(), $info);
+                $context->getContextValue(), $info);
         } catch (\Throwable $error) {
             return $error;
         }
@@ -444,51 +444,51 @@ 
      * @throws \Throwable
      */
     public function completeValueCatchingError(
-      TypeInterface $fieldType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        TypeInterface $fieldType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
         if ($fieldType instanceof NonNullType) {
             return $this->completeValueWithLocatedError(
-              $fieldType,
-              $fieldNodes,
-              $info,
-              $path,
-              $result
+                $fieldType,
+                $fieldNodes,
+                $info,
+                $path,
+                $result
             );
         }
 
         try {
             $completed = $this->completeValueWithLocatedError(
-              $fieldType,
-              $fieldNodes,
-              $info,
-              $path,
-              $result
+                $fieldType,
+                $fieldNodes,
+                $info,
+                $path,
+                $result
             );
 
             if ($this->isPromise($completed)) {
                 $context = $this->context;
                 /** @var ExtendedPromiseInterface $completed */
                 return $completed->then(null,
-                  function ($error) use ($context, $fieldNodes, $path) {
-                      //@TODO Handle $error better
-                      if ($error instanceof \Exception) {
-                          $context->addError($this->buildLocatedError($error,
+                    function ($error) use ($context, $fieldNodes, $path) {
+                        //@TODO Handle $error better
+                        if ($error instanceof \Exception) {
+                            $context->addError($this->buildLocatedError($error,
                             $fieldNodes, $path));
-                      } else {
-                          $context->addError(
+                        } else {
+                            $context->addError(
                             $this->buildLocatedError(
-                              new ExecutionException($error ?? 'An unknown error occurred.'),
-                              $fieldNodes,
-                              $path
+                                new ExecutionException($error ?? 'An unknown error occurred.'),
+                                $fieldNodes,
+                                $path
                             )
-                          );
-                      }
-                      return new \React\Promise\FulfilledPromise(null);
-                  });
+                            );
+                        }
+                        return new \React\Promise\FulfilledPromise(null);
+                    });
             }
 
             return $completed;
@@ -497,7 +497,7 @@ 
             return null;
         } catch (\Exception $ex) {
             $this->context->addError($this->buildLocatedError($ex, $fieldNodes,
-              $path));
+                $path));
             return null;
         }
     }
@@ -512,19 +512,19 @@ 
      * @throws \Throwable
      */
     public function completeValueWithLocatedError(
-      TypeInterface $fieldType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      $result
+        TypeInterface $fieldType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        $result
     ) {
         try {
             $completed = $this->completeValue(
-              $fieldType,
-              $fieldNodes,
-              $info,
-              $path,
-              $result
+                $fieldType,
+                $fieldNodes,
+                $info,
+                $path,
+                $result
             );
 
             return $completed;
@@ -545,22 +545,22 @@ 
      * @throws \Throwable
      */
     private function completeValue(
-      TypeInterface $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        TypeInterface $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
         if ($this->isPromise($result)) {
             /** @var ExtendedPromiseInterface $result */
             return $result->then(function (&$value) use (
-              $returnType,
-              $fieldNodes,
-              $info,
-              $path
+                $returnType,
+                $fieldNodes,
+                $info,
+                $path
             ) {
                 return $this->completeValue($returnType, $fieldNodes, $info,
-                  $path, $value);
+                    $path, $value);
             });
         }
 
@@ -575,19 +575,19 @@ 
 
         if ($returnType instanceof NonNullType) {
             $completed = $this->completeValue(
-              $returnType->getOfType(),
-              $fieldNodes,
-              $info,
-              $path,
-              $result
+                $returnType->getOfType(),
+                $fieldNodes,
+                $info,
+                $path,
+                $result
             );
 
             if ($completed === null) {
                 throw new ExecutionException(
-                  sprintf(
+                    sprintf(
                     'Cannot return null for non-nullable field %s.%s.',
                     $info->getParentType(), $info->getFieldName()
-                  )
+                    )
                 );
             }
 
@@ -597,7 +597,7 @@ 
         // If field type is List, complete each item in the list with the inner type
         if ($returnType instanceof ListType) {
             return $this->completeListValue($returnType, $fieldNodes, $info,
-              $path, $result);
+                $path, $result);
         }
 
 
@@ -610,13 +610,13 @@ 
         //@TODO Make a function for checking abstract type?
         if ($returnType instanceof InterfaceType || $returnType instanceof UnionType) {
             return $this->completeAbstractValue($returnType, $fieldNodes, $info,
-              $path, $result);
+                $path, $result);
         }
 
         // Field type must be Object, Interface or Union and expect sub-selections.
         if ($returnType instanceof ObjectType) {
             return $this->completeObjectValue($returnType, $fieldNodes, $info,
-              $path, $result);
+                $path, $result);
         }
 
         throw new ExecutionException("Cannot complete value of unexpected type \"{$returnType}\".");
@@ -643,11 +643,11 @@ 
      * @throws \Throwable
      */
     private function completeListValue(
-      ListType $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        ListType $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
         $itemType = $returnType->getOfType();
 
@@ -656,11 +656,11 @@ 
 
         if (!is_array($result) && !($result instanceof \Traversable)) {
             throw new \Exception(
-              sprintf(
+                sprintf(
                 'Expected Array or Traversable, but did not find one for field %s.%s.',
                 $info->getParentType()->getName(),
                 $info->getFieldName()
-              )
+                )
             );
         }
 
@@ -668,7 +668,7 @@ 
             $fieldPath = $path;
             $fieldPath[] = $key;
             $completedItem = $this->completeValueCatchingError($itemType,
-              $fieldNodes, $info, $fieldPath, $item);
+                $fieldNodes, $info, $fieldPath, $item);
             $completedItems[] = $completedItem;
             $containsPromise = $containsPromise || $this->isPromise($completedItem);
         }
@@ -690,7 +690,7 @@ 
         if ($serializedResult === null) {
             //@TODO Make a function for this type of exception
             throw new ExecutionException(
-              sprintf('Expected value of type "%s" but received: %s.',
+                sprintf('Expected value of type "%s" but received: %s.',
                 (string)$returnType, toString($result))
             );
         }
@@ -712,58 +712,58 @@ 
      * @throws \Throwable
      */
     private function completeAbstractValue(
-      AbstractTypeInterface $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        AbstractTypeInterface $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
         $runtimeType = $returnType->resolveType($result,
-          $this->context->getContextValue(), $info);
+            $this->context->getContextValue(), $info);
 
         if (null === $runtimeType) {
             //@TODO Show warning
             $runtimeType = $this->defaultTypeResolver($result,
-              $this->context->getContextValue(), $info, $returnType);
+                $this->context->getContextValue(), $info, $returnType);
         }
 
         if ($this->isPromise($runtimeType)) {
             /** @var ExtendedPromiseInterface $runtimeType */
             return $runtimeType->then(function ($resolvedRuntimeType) use (
-              $returnType,
-              $fieldNodes,
-              $info,
-              $path,
-              &$result
+                $returnType,
+                $fieldNodes,
+                $info,
+                $path,
+                &$result
             ) {
                 return $this->completeObjectValue(
-                  $this->ensureValidRuntimeType(
+                    $this->ensureValidRuntimeType(
                     $resolvedRuntimeType,
                     $returnType,
                     $fieldNodes,
                     $info,
                     $result
-                  ),
-                  $fieldNodes,
-                  $info,
-                  $path,
-                  $result
+                    ),
+                    $fieldNodes,
+                    $info,
+                    $path,
+                    $result
                 );
             });
         }
 
         return $this->completeObjectValue(
-          $this->ensureValidRuntimeType(
+            $this->ensureValidRuntimeType(
             $runtimeType,
             $returnType,
             $fieldNodes,
             $info,
             $result
-          ),
-          $fieldNodes,
-          $info,
-          $path,
-          $result
+            ),
+            $fieldNodes,
+            $info,
+            $path,
+            $result
         );
     }
 
@@ -777,10 +777,10 @@ 
      * @throws ExecutionException
      */
     private function defaultTypeResolver(
-      $value,
-      $context,
-      ResolveInfo $info,
-      AbstractTypeInterface $abstractType
+        $value,
+        $context,
+        ResolveInfo $info,
+        AbstractTypeInterface $abstractType
     ) {
         $possibleTypes = $info->getSchema()->getPossibleTypes($abstractType);
         $promisedIsTypeOfResults = [];
@@ -808,14 +808,14 @@ 
 
         if (!empty($promisedIsTypeOfResults)) {
             return \React\Promise\all($promisedIsTypeOfResults)
-              ->then(function ($isTypeOfResults) use ($possibleTypes) {
-                  foreach ($isTypeOfResults as $index => $result) {
-                      if ($result) {
-                          return $possibleTypes[$index];
-                      }
-                  }
-                  return null;
-              });
+                ->then(function ($isTypeOfResults) use ($possibleTypes) {
+                    foreach ($isTypeOfResults as $index => $result) {
+                        if ($result) {
+                            return $possibleTypes[$index];
+                        }
+                    }
+                    return null;
+                });
         }
 
         return null;
@@ -835,31 +835,31 @@ 
      * @throws \Throwable
      */
     private function completeObjectValue(
-      ObjectType $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        ObjectType $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
 
         if (null !== $returnType->getIsTypeOf()) {
             $isTypeOf = $returnType->isTypeOf($result,
-              $this->context->getContextValue(), $info);
+                $this->context->getContextValue(), $info);
             //@TODO check for promise?
             if (!$isTypeOf) {
                 throw new ExecutionException(
-                  sprintf('Expected value of type "%s" but received: %s.',
+                    sprintf('Expected value of type "%s" but received: %s.',
                     (string)$returnType, toString($result))
                 );
             }
         }
 
         return $this->collectAndExecuteSubFields(
-          $returnType,
-          $fieldNodes,
-          $info,
-          $path,
-          $result
+            $returnType,
+            $fieldNodes,
+            $info,
+            $path,
+            $result
         );
     }
 
@@ -877,11 +877,11 @@ 
      * @throws \Throwable
      */
     private function collectAndExecuteSubFields(
-      ObjectType $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      $path,
-      &$result
+        ObjectType $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        $path,
+        &$result
     ) {
         $subFields = [];
         $visitedFragmentNames = [];
@@ -890,17 +890,17 @@ 
             /** @var FieldNode $fieldNode */
             if ($fieldNode->getSelectionSet() !== null) {
                 $subFields = $this->collectFields(
-                  $returnType,
-                  $fieldNode->getSelectionSet(),
-                  $subFields,
-                  $visitedFragmentNames
+                    $returnType,
+                    $fieldNode->getSelectionSet(),
+                    $subFields,
+                    $visitedFragmentNames
                 );
             }
         }
 
         if (!empty($subFields)) {
             return $this->executeFields($returnType, $result, $path,
-              $subFields);
+                $subFields);
         }
 
         return $result;
@@ -918,10 +918,10 @@ 
      * @throws \Digia\GraphQL\Error\InvariantException
      */
     protected function collectFields(
-      ObjectType $runtimeType,
-      SelectionSetNode $selectionSet,
-      &$fields,
-      &$visitedFragmentNames
+        ObjectType $runtimeType,
+        SelectionSetNode $selectionSet,
+        &$fields,
+        &$visitedFragmentNames
     ) {
         foreach ($selectionSet->getSelections() as $selection) {
             // Check if this Node should be included first
@@ -939,13 +939,13 @@ 
                 $fields[$fieldName][] = $selection;
             } elseif ($selection instanceof InlineFragmentNode) {
                 if (!$this->doesFragmentConditionMatch($selection,
-                  $runtimeType)) {
+                    $runtimeType)) {
                     continue;
                 }
 
                 $this->collectFields($runtimeType,
-                  $selection->getSelectionSet(), $fields,
-                  $visitedFragmentNames);
+                    $selection->getSelectionSet(), $fields,
+                    $visitedFragmentNames);
             } elseif ($selection instanceof FragmentSpreadNode) {
                 $fragmentName = $selection->getNameValue();
 
@@ -957,7 +957,7 @@ 
                 /** @var FragmentDefinitionNode $fragment */
                 $fragment = $this->context->getFragments()[$fragmentName];
                 $this->collectFields($runtimeType, $fragment->getSelectionSet(),
-                  $fields, $visitedFragmentNames);
+                    $fields, $visitedFragmentNames);
             }
         }
 
@@ -978,14 +978,14 @@ 
         $contextVariables = $this->context->getVariableValues();
 
         $skip = coerceDirectiveValues(SkipDirective(), $node,
-          $contextVariables);
+            $contextVariables);
 
         if ($skip && $skip['if'] === true) {
             return false;
         }
 
         $include = coerceDirectiveValues(IncludeDirective(), $node,
-          $contextVariables);
+            $contextVariables);
 
         if ($include && $include['if'] === false) {
             return false;
@@ -1004,7 +1004,7 @@ 
     private function getFieldNameKey(FieldNode $node): string
     {
         return $node->getAlias() ? $node->getAlias()
-          ->getValue() : $node->getNameValue();
+            ->getValue() : $node->getNameValue();
     }
 
     /**
@@ -1015,8 +1015,8 @@ 
      * @throws InvalidTypeException
      */
     private function doesFragmentConditionMatch(
-      NodeInterface $fragment,
-      ObjectType $type
+        NodeInterface $fragment,
+        ObjectType $type
     ): bool {
         $typeConditionNode = $fragment->getTypeCondition();
 
@@ -1025,7 +1025,7 @@ 
         }
 
         $conditionalType = typeFromAST($this->context->getSchema(),
-          $typeConditionNode);
+            $typeConditionNode);
 
         if ($conditionalType === $type) {
             return true;
@@ -1033,7 +1033,7 @@ 
 
         if ($conditionalType instanceof AbstractTypeInterface) {
             return $this->context->getSchema()
-              ->isPossibleType($conditionalType, $type);
+                ->isPossibleType($conditionalType, $type);
         }
 
         return false;
@@ -1050,11 +1050,11 @@ 
      * @throws ExecutionException
      */
     private function ensureValidRuntimeType(
-      $runtimeTypeOrName,
-      AbstractTypeInterface $returnType,
-      $fieldNodes,
-      ResolveInfo $info,
-      &$result
+        $runtimeTypeOrName,
+        AbstractTypeInterface $returnType,
+        $fieldNodes,
+        ResolveInfo $info,
+        &$result
     ) {
         $runtimeType = is_string($runtimeTypeOrName)
           ? $this->context->getSchema()->getType($runtimeTypeOrName)
@@ -1068,25 +1068,25 @@ 
             $fieldName = $info->getFieldName();
 
             throw new ExecutionException(
-              "Abstract type {$returnTypeName} must resolve to an Object type at runtime " .
-              "for field {$parentTypeName}.{$fieldName} with " .
-              'value "' . $result . '", received "{$runtimeTypeName}".'
+                "Abstract type {$returnTypeName} must resolve to an Object type at runtime " .
+                "for field {$parentTypeName}.{$fieldName} with " .
+                'value "' . $result . '", received "{$runtimeTypeName}".'
             );
         }
 
         if (!$this->context->getSchema()
-          ->isPossibleType($returnType, $runtimeType)) {
+            ->isPossibleType($returnType, $runtimeType)) {
             throw new ExecutionException(
-              "Runtime Object type \"{$runtimeTypeName}\" is not a possible type for \"{$returnTypeName}\"."
+                "Runtime Object type \"{$runtimeTypeName}\" is not a possible type for \"{$returnTypeName}\"."
             );
         }
 
         if ($runtimeType !== $this->context->getSchema()
             ->getType($runtimeType->getName())) {
             throw new ExecutionException(
-              "Schema must contain unique named types but contains multiple types named \"{$runtimeTypeName}\". " .
-              "Make sure that `resolveType` function of abstract type \"{$returnTypeName}\" returns the same " .
-              "type instance as referenced anywhere else within the schema."
+                "Schema must contain unique named types but contains multiple types named \"{$runtimeTypeName}\". " .
+                "Make sure that `resolveType` function of abstract type \"{$returnTypeName}\" returns the same " .
+                "type instance as referenced anywhere else within the schema."
             );
         }
 
@@ -1101,17 +1101,17 @@ 
      * @return GraphQLException
      */
     protected function buildLocatedError(
-      \Throwable $originalException,
-      array $nodes = [],
-      array $path = []
+        \Throwable $originalException,
+        array $nodes = [],
+        array $path = []
     ): ExecutionException {
         return new ExecutionException(
-          $originalException->getMessage(),
-          $originalException instanceof GraphQLException ? $originalException->getNodes() : $nodes,
-          $originalException instanceof GraphQLException ? $originalException->getSource() : null,
-          $originalException instanceof GraphQLException ? $originalException->getPositions() : null,
-          $originalException instanceof GraphQLException ? ($originalException->getPath() ?? $path) : $path,
-          $originalException
+            $originalException->getMessage(),
+            $originalException instanceof GraphQLException ? $originalException->getNodes() : $nodes,
+            $originalException instanceof GraphQLException ? $originalException->getSource() : null,
+            $originalException instanceof GraphQLException ? $originalException->getPositions() : null,
+            $originalException instanceof GraphQLException ? ($originalException->getPath() ?? $path) : $path,
+            $originalException
         );
     }
 }

Spacing +9 added lines, -9 removed lines

@@ -152,7 +152,7 @@ 
 
         $promise = new \React\Promise\FulfilledPromise([]);
 
-        $resolve = function (
+        $resolve = function(
           $results,
           $fieldName,
           $path,
@@ -171,7 +171,7 @@ 
 
             if ($this->isPromise($result)) {
                 /** @var ExtendedPromiseInterface $result */
-                return $result->then(function ($resolvedResult) use (
+                return $result->then(function($resolvedResult) use (
                   $fieldName,
                   $results
                 ) {
@@ -186,7 +186,7 @@ 
         };
 
         foreach ($fields as $fieldName => $fieldNodes) {
-            $promise = $promise->then(function ($resolvedResults) use (
+            $promise = $promise->then(function($resolvedResults) use (
               $resolve,
               $fieldName,
               $path,
@@ -199,7 +199,7 @@ 
             });
         }
 
-        $promise->then(function ($resolvedResults) use (&$finalResults) {
+        $promise->then(function($resolvedResults) use (&$finalResults) {
             $finalResults = $resolvedResults ?? [];
         });
 
@@ -249,7 +249,7 @@ 
         if ($isContainsPromise) {
             $keys = array_keys($finalResults);
             $promise = \React\Promise\all(array_values($finalResults));
-            $promise->then(function ($values) use ($keys, &$finalResults) {
+            $promise->then(function($values) use ($keys, &$finalResults) {
                 foreach ($values as $i => $value) {
                     $finalResults[$keys[$i]] = $value;
                 }
@@ -473,7 +473,7 @@ 
                 $context = $this->context;
                 /** @var ExtendedPromiseInterface $completed */
                 return $completed->then(null,
-                  function ($error) use ($context, $fieldNodes, $path) {
+                  function($error) use ($context, $fieldNodes, $path) {
                       //@TODO Handle $error better
                       if ($error instanceof \Exception) {
                           $context->addError($this->buildLocatedError($error,
@@ -553,7 +553,7 @@ 
     ) {
         if ($this->isPromise($result)) {
             /** @var ExtendedPromiseInterface $result */
-            return $result->then(function (&$value) use (
+            return $result->then(function(&$value) use (
               $returnType,
               $fieldNodes,
               $info,
@@ -729,7 +729,7 @@ 
 
         if ($this->isPromise($runtimeType)) {
             /** @var ExtendedPromiseInterface $runtimeType */
-            return $runtimeType->then(function ($resolvedRuntimeType) use (
+            return $runtimeType->then(function($resolvedRuntimeType) use (
               $returnType,
               $fieldNodes,
               $info,
@@ -808,7 +808,7 @@ 
 
         if (!empty($promisedIsTypeOfResults)) {
             return \React\Promise\all($promisedIsTypeOfResults)
-              ->then(function ($isTypeOfResults) use ($possibleTypes) {
+              ->then(function($isTypeOfResults) use ($possibleTypes) {
                   foreach ($isTypeOfResults as $index => $result) {
                       if ($result) {
                           return $possibleTypes[$index];