digiaonline / graphql-php

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];

src/Execution/ExecutionProvider.php

Indentation +7 added lines, -7 removed lines

@@ -16,9 +16,9 @@ 
      * @var array
      */
     protected $provides = [
-      ExecutionContextBuilder::class,
-      ExecutionInterface::class,
-      ValuesHelper::class,
+        ExecutionContextBuilder::class,
+        ExecutionInterface::class,
+        ValuesHelper::class,
     ];
 
     /**
@@ -27,11 +27,11 @@ 
     public function register()
     {
         $this->container->add(ExecutionContextBuilder::class,
-          ExecutionContextBuilder::class, true/* $shared */);
+            ExecutionContextBuilder::class, true/* $shared */);
         $this->container->add(ExecutionInterface::class, Execution::class,
-          true/* $shared */)
-          ->withArgument(ExecutionContextBuilder::class);
+            true/* $shared */)
+            ->withArgument(ExecutionContextBuilder::class);
         $this->container->add(ValuesHelper::class, ValuesHelper::class,
-          true/* $shared */);
+            true/* $shared */);
     }
 }

src/Execution/ExecutionArguments.php

Indentation +7 added lines, -7 removed lines

@@ -56,13 +56,13 @@
      * @param mixed $fieldResolver
      */
     public function __construct(
-      Schema $schema,
-      DocumentNode $document,
-      $rootValue,
-      $contextValue,
-      array $variableValues,
-      OperationDefinitionNode $operation,
-      $fieldResolver
+        Schema $schema,
+        DocumentNode $document,
+        $rootValue,
+        $contextValue,
+        array $variableValues,
+        OperationDefinitionNode $operation,
+        $fieldResolver
     ) {
         $this->schema = $schema;
         $this->document = $document;

src/Execution/Execution.php

Indentation +14 added lines, -14 removed lines

@@ -42,23 +42,23 @@
      * @throws \Exception
      */
     public function execute(
-      Schema $schema,
-      DocumentNode $documentNode,
-      $rootValue = null,
-      $contextValue = null,
-      $variableValues = [],
-      $operationName = null,
-      callable $fieldResolver = null
+        Schema $schema,
+        DocumentNode $documentNode,
+        $rootValue = null,
+        $contextValue = null,
+        $variableValues = [],
+        $operationName = null,
+        callable $fieldResolver = null
     ): ExecutionResult {
         try {
             $context = $this->contextBuilder->buildContext(
-              $schema,
-              $documentNode,
-              $rootValue,
-              $contextValue,
-              $variableValues,
-              $operationName,
-              $fieldResolver
+                $schema,
+                $documentNode,
+                $rootValue,
+                $contextValue,
+                $variableValues,
+                $operationName,
+                $fieldResolver
             );
 
             // Return early errors if execution context failed.

src/Execution/ExecutionInterface.php

Indentation +7 added lines, -7 removed lines

@@ -20,12 +20,12 @@
      * @return mixed
      */
     public function execute(
-      Schema $schema,
-      DocumentNode $documentNode,
-      $rootValue = null,
-      $contextValue = null,
-      $variableValues = [],
-      $operationName = null,
-      callable $fieldResolver = null
+        Schema $schema,
+        DocumentNode $documentNode,
+        $rootValue = null,
+        $contextValue = null,
+        $variableValues = [],
+        $operationName = null,
+        callable $fieldResolver = null
     ): ExecutionResult;
 }

src/Execution/ExecutorExecutionStrategy.php

Indentation +5 added lines, -5 removed lines

@@ -26,10 +26,10 @@ 
         $visitedFragmentNames = [];
         try {
             $fields = $this->collectFields(
-              $objectType,
-              $this->operation->getSelectionSet(),
-              $fields,
-              $visitedFragmentNames
+                $objectType,
+                $this->operation->getSelectionSet(),
+                $fields,
+                $visitedFragmentNames
             );
 
             $result = ($operation === 'mutation')
@@ -40,7 +40,7 @@ 
 
         } catch (\Exception $ex) {
             $this->context->addError(
-              new ExecutionException($ex->getMessage())
+                new ExecutionException($ex->getMessage())
             );
 
             //@TODO return [null]

src/api.php

Indentation +35 added lines, -35 removed lines

@@ -23,9 +23,9 @@ 
  * @throws InvariantException
  */
 function buildSchema(
-  $source,
-  $resolverRegistry = [],
-  array $options = []
+    $source,
+    $resolverRegistry = [],
+    array $options = []
 ): SchemaInterface {
     return GraphQL::buildSchema($source, $resolverRegistry, $options);
 }
@@ -40,10 +40,10 @@ 
  * @throws InvariantException
  */
 function extendSchema(
-  SchemaInterface $schema,
-  $source,
-  $resolverRegistry = [],
-  array $options = []
+    SchemaInterface $schema,
+    $source,
+    $resolverRegistry = [],
+    array $options = []
 ): SchemaInterface {
     return GraphQL::extendSchema($schema, $source, $resolverRegistry, $options);
 }
@@ -120,22 +120,22 @@ 
  * @return ExecutionResult
  */
 function execute(
-  SchemaInterface $schema,
-  DocumentNode $document,
-  $rootValue = null,
-  $contextValue = null,
-  array $variableValues = [],
-  $operationName = null,
-  callable $fieldResolver = null
+    SchemaInterface $schema,
+    DocumentNode $document,
+    $rootValue = null,
+    $contextValue = null,
+    array $variableValues = [],
+    $operationName = null,
+    callable $fieldResolver = null
 ): ExecutionResult {
     return GraphQL::execute(
-      $schema,
-      $document,
-      $rootValue,
-      $contextValue,
-      $variableValues,
-      $operationName,
-      $fieldResolver
+        $schema,
+        $document,
+        $rootValue,
+        $contextValue,
+        $variableValues,
+        $operationName,
+        $fieldResolver
     );
 }
 
@@ -162,13 +162,13 @@ 
  * @throws InvariantException
  */
 function graphql(
-  SchemaInterface $schema,
-  string $source,
-  $rootValue = null,
-  $contextValue = null,
-  array $variableValues = [],
-  $operationName = null,
-  callable $fieldResolver = null
+    SchemaInterface $schema,
+    string $source,
+    $rootValue = null,
+    $contextValue = null,
+    array $variableValues = [],
+    $operationName = null,
+    callable $fieldResolver = null
 ): array {
     $schemaValidationErrors = validateSchema($schema);
     if (!empty($schemaValidationErrors)) {
@@ -189,13 +189,13 @@ 
     }
 
     $result = execute(
-      $schema,
-      $document,
-      $rootValue,
-      $contextValue,
-      $variableValues,
-      $operationName,
-      $fieldResolver
+        $schema,
+        $document,
+        $rootValue,
+        $contextValue,
+        $variableValues,
+        $operationName,
+        $fieldResolver
     );
 
     return $result->toArray();

src/GraphQL.php

Indentation +48 added lines, -48 removed lines

@@ -81,19 +81,19 @@ 
      * @var array
      */
     private static $providers = [
-      CacheProvider::class,
-      LanguageProvider::class,
-      SchemaBuildingProvider::class,
-      SchemaExtensionProvider::class,
-      SchemaValidationProvider::class,
-      CoercerProvider::class,
-      IntrospectionProvider::class,
-      ScalarTypesProvider::class,
-      DirectivesProvider::class,
-      RulesProvider::class,
-      ValidationProvider::class,
-      ExecutionProvider::class,
-      UtilityProvider::class,
+        CacheProvider::class,
+        LanguageProvider::class,
+        SchemaBuildingProvider::class,
+        SchemaExtensionProvider::class,
+        SchemaValidationProvider::class,
+        CoercerProvider::class,
+        IntrospectionProvider::class,
+        ScalarTypesProvider::class,
+        DirectivesProvider::class,
+        RulesProvider::class,
+        ValidationProvider::class,
+        ExecutionProvider::class,
+        UtilityProvider::class,
     ];
 
     /**
@@ -137,18 +137,18 @@ 
      * @throws InvariantException
      */
     public static function buildSchema(
-      $source,
-      $resolverRegistry,
-      array $options = []
+        $source,
+        $resolverRegistry,
+        array $options = []
     ): SchemaInterface {
         return static::make(SchemaBuilderInterface::class)
-          ->build(
+            ->build(
             static::parse($source, $options),
             $resolverRegistry instanceof ResolverRegistryInterface
               ? $resolverRegistry
               : new ResolverRegistry($resolverRegistry),
             $options
-          );
+            );
     }
 
     /**
@@ -160,8 +160,8 @@ 
     public static function make(string $id, array $args = [])
     {
         return static::getInstance()
-          ->getContainer()
-          ->get($id, $args);
+            ->getContainer()
+            ->get($id, $args);
     }
 
     /**
@@ -194,7 +194,7 @@ 
     public static function parse($source, array $options = []): DocumentNode
     {
         return static::make(ParserInterface::class)
-          ->parse(static::lex($source, $options));
+            ->parse(static::lex($source, $options));
     }
 
     /**
@@ -208,8 +208,8 @@ 
     {
         // TODO: Introduce a LexerCreator to allow setting source and options via the constructor.
         return static::make(LexerInterface::class)
-          ->setSource($source instanceof Source ? $source : new Source($source))
-          ->setOptions($options);
+            ->setSource($source instanceof Source ? $source : new Source($source))
+            ->setOptions($options);
     }
 
     /**
@@ -222,20 +222,20 @@ 
      * @throws InvariantException
      */
     public static function extendSchema(
-      SchemaInterface $schema,
-      $source,
-      $resolverRegistry,
-      array $options = []
+        SchemaInterface $schema,
+        $source,
+        $resolverRegistry,
+        array $options = []
     ): SchemaInterface {
         return static::make(SchemaExtenderInterface::class)
-          ->extend(
+            ->extend(
             $schema,
             static::parse($source, $options),
             $resolverRegistry instanceof ResolverRegistryInterface
               ? $resolverRegistry
               : new ResolverRegistry($resolverRegistry),
             $options
-          );
+            );
     }
 
     /**
@@ -246,7 +246,7 @@ 
     public static function validateSchema(SchemaInterface $schema): array
     {
         return static::make(SchemaValidatorInterface::class)
-          ->validate($schema);
+            ->validate($schema);
     }
 
     /**
@@ -257,11 +257,11 @@ 
      * @throws InvariantException
      */
     public static function parseValue(
-      $source,
-      array $options = []
+        $source,
+        array $options = []
     ): ValueNodeInterface {
         return static::make(ParserInterface::class)
-          ->parseValue(static::lex($source, $options));
+            ->parseValue(static::lex($source, $options));
     }
 
     /**
@@ -272,11 +272,11 @@ 
      * @throws InvariantException
      */
     public static function parseType(
-      $source,
-      array $options = []
+        $source,
+        array $options = []
     ): TypeNodeInterface {
         return static::make(ParserInterface::class)
-          ->parseType(static::lex($source, $options));
+            ->parseType(static::lex($source, $options));
     }
 
     /**
@@ -286,11 +286,11 @@ 
      * @return array
      */
     public static function validate(
-      SchemaInterface $schema,
-      DocumentNode $document
+        SchemaInterface $schema,
+        DocumentNode $document
     ): array {
         return static::make(ValidatorInterface::class)
-          ->validate($schema, $document);
+            ->validate($schema, $document);
     }
 
     /**
@@ -305,16 +305,16 @@ 
      * @return ExecutionResult
      */
     public static function execute(
-      SchemaInterface $schema,
-      DocumentNode $document,
-      $rootValue = null,
-      $contextValue = null,
-      array $variableValues = [],
-      $operationName = null,
-      callable $fieldResolver = null
+        SchemaInterface $schema,
+        DocumentNode $document,
+        $rootValue = null,
+        $contextValue = null,
+        array $variableValues = [],
+        $operationName = null,
+        callable $fieldResolver = null
     ): ExecutionResult {
         return static::make(ExecutionInterface::class)
-          ->execute(
+            ->execute(
             $schema,
             $document,
             $rootValue,
@@ -322,7 +322,7 @@ 
             $variableValues,
             $operationName,
             $fieldResolver
-          );
+            );
     }
 
     /**