digiaonline / graphql-php

src/Cache/CacheProvider.php

Indentation +1 added lines, -1 removed lines

@@ -12,7 +12,7 @@
      * @var array
      */
     protected $provides = [
-      CacheInterface::class,
+        CacheInterface::class,
     ];
 
     /**

src/Schema/Extension/SchemaExtender.php

Indentation +40 added lines, -40 removed lines

@@ -45,10 +45,10 @@ 
      * @inheritdoc
      */
     public function extend(
-      SchemaInterface $schema,
-      DocumentNode $document,
+        SchemaInterface $schema,
+        DocumentNode $document,
       ?ResolverRegistryInterface $resolverRegistry = null,
-      array $options = []
+        array $options = []
     ): SchemaInterface {
         $context = $this->createContext($schema, $document, $resolverRegistry);
 
@@ -59,12 +59,12 @@ 
         }
 
         return newSchema([
-          'query' => $context->getExtendedQueryType(),
-          'mutation' => $context->getExtendedMutationType(),
-          'subscription' => $context->getExtendedSubscriptionType(),
-          'types' => $context->getExtendedTypes(),
-          'directives' => $context->getExtendedDirectives(),
-          'astNode' => $schema->getAstNode(),
+            'query' => $context->getExtendedQueryType(),
+            'mutation' => $context->getExtendedMutationType(),
+            'subscription' => $context->getExtendedSubscriptionType(),
+            'types' => $context->getExtendedTypes(),
+            'directives' => $context->getExtendedDirectives(),
+            'astNode' => $schema->getAstNode(),
         ]);
     }
 
@@ -72,8 +72,8 @@ 
      * @inheritdoc
      */
     public function createContext(
-      SchemaInterface $schema,
-      DocumentNode $document,
+        SchemaInterface $schema,
+        DocumentNode $document,
       ?ResolverRegistryInterface $resolverRegistry
     ): ExtensionContextInterface {
         $info = $this->createInfo($schema, $document);
@@ -83,10 +83,10 @@ 
         $context = new ExtensionContext($info);
 
         $definitionBuilder = new DefinitionBuilder(
-          $info->getTypeDefinitionMap(),
-          $resolverRegistry,
-          [$context, 'resolveType'],
-          $this->cache
+            $info->getTypeDefinitionMap(),
+            $resolverRegistry,
+            [$context, 'resolveType'],
+            $this->cache
         );
 
         return $context->setDefinitionBuilder($definitionBuilder);
@@ -100,8 +100,8 @@ 
      * @throws ExtensionException
      */
     protected function createInfo(
-      SchemaInterface $schema,
-      DocumentNode $document
+        SchemaInterface $schema,
+        DocumentNode $document
     ): ExtendInfo {
         $typeDefinitionMap = [];
         $typeExtensionsMap = [];
@@ -115,12 +115,12 @@ 
 
                 if (null !== $existingType) {
                     throw new ExtensionException(
-                      \sprintf(
+                        \sprintf(
                         'Type "%s" already exists in the schema. It cannot also ' .
                         'be defined in this type definition.',
                         $typeName
-                      ),
-                      [$definition]
+                        ),
+                        [$definition]
                     );
                 }
 
@@ -136,19 +136,19 @@ 
 
                 if (null === $existingType) {
                     throw new ExtensionException(
-                      \sprintf(
+                        \sprintf(
                         'Cannot extend type "%s" because it does not exist in the existing schema.',
                         $extendedTypeName
-                      ),
-                      [$definition]
+                        ),
+                        [$definition]
                     );
                 }
 
                 $this->checkExtensionNode($existingType, $definition);
 
                 $typeExtensionsMap[$extendedTypeName] = \array_merge(
-                  $typeExtensionsMap[$extendedTypeName] ?? [],
-                  [$definition]
+                    $typeExtensionsMap[$extendedTypeName] ?? [],
+                    [$definition]
                 );
 
                 continue;
@@ -160,11 +160,11 @@ 
 
                 if (null !== $existingDirective) {
                     throw new ExtensionException(
-                      \sprintf(
+                        \sprintf(
                         'Directive "%s" already exists in the schema. It cannot be redefined.',
                         $directiveName
-                      ),
-                      [$definition]
+                        ),
+                        [$definition]
                     );
                 }
 
@@ -178,18 +178,18 @@ 
               $definition instanceof EnumTypeExtensionNode ||
               $definition instanceof InputObjectTypeExtensionNode) {
                 throw new ExtensionException(
-                  \sprintf('The %s kind is not yet supported by extendSchema().',
+                    \sprintf('The %s kind is not yet supported by extendSchema().',
                     $definition->getKind())
                 );
             }
         }
 
         return new ExtendInfo(
-          $schema,
-          $document,
-          $typeDefinitionMap,
-          $typeExtensionsMap,
-          $directiveDefinitions
+            $schema,
+            $document,
+            $typeDefinitionMap,
+            $typeExtensionsMap,
+            $directiveDefinitions
         );
     }
 
@@ -200,21 +200,21 @@ 
      * @throws ExtensionException
      */
     protected function checkExtensionNode(
-      TypeInterface $type,
-      NodeInterface $node
+        TypeInterface $type,
+        NodeInterface $node
     ): void {
         if ($node instanceof ObjectTypeExtensionNode && !($type instanceof ObjectType)) {
             throw new ExtensionException(
-              \sprintf('Cannot extend non-object type "%s".', toString($type)),
-              [$node]
+                \sprintf('Cannot extend non-object type "%s".', toString($type)),
+                [$node]
             );
         }
 
         if ($node instanceof InterfaceTypeExtensionNode && !($type instanceof InterfaceType)) {
             throw new ExtensionException(
-              \sprintf('Cannot extend non-interface type "%s".',
+                \sprintf('Cannot extend non-interface type "%s".',
                 toString($type)),
-              [$node]
+                [$node]
             );
         }
     }

src/Schema/Extension/ExtendInfo.php

Indentation +5 added lines, -5 removed lines

@@ -47,11 +47,11 @@
      * @param DirectiveDefinitionNode[] $directiveDefinitions
      */
     public function __construct(
-      SchemaInterface $schema,
-      DocumentNode $document,
-      array $typeDefinitionMap,
-      array $typeExtensionsMap,
-      array $directiveDefinitions
+        SchemaInterface $schema,
+        DocumentNode $document,
+        array $typeDefinitionMap,
+        array $typeExtensionsMap,
+        array $directiveDefinitions
     ) {
         $this->schema = $schema;
         $this->document = $document;

src/Schema/Extension/SchemaExtensionProvider.php

Indentation +3 added lines, -3 removed lines

@@ -12,7 +12,7 @@ 
      * @var array
      */
     protected $provides = [
-      SchemaExtenderInterface::class,
+        SchemaExtenderInterface::class,
     ];
 
     /**
@@ -21,7 +21,7 @@ 
     public function register()
     {
         $this->container->add(SchemaExtenderInterface::class,
-          SchemaExtender::class)
-          ->withArgument(CacheInterface::class);
+            SchemaExtender::class)
+            ->withArgument(CacheInterface::class);
     }
 }

src/Schema/Extension/SchemaExtenderInterface.php

Indentation +5 added lines, -5 removed lines

@@ -18,10 +18,10 @@ 
      * @return SchemaInterface
      */
     public function extend(
-      SchemaInterface $schema,
-      DocumentNode $document,
+        SchemaInterface $schema,
+        DocumentNode $document,
       ?ResolverRegistryInterface $resolverRegistry = null,
-      array $options = []
+        array $options = []
     ): SchemaInterface;
 
     /**
@@ -32,8 +32,8 @@ 
      * @return ExtensionContextInterface
      */
     public function createContext(
-      SchemaInterface $schema,
-      DocumentNode $document,
+        SchemaInterface $schema,
+        DocumentNode $document,
       ?ResolverRegistryInterface $resolverRegistry
     ): ExtensionContextInterface;
 }

src/Schema/Extension/ExtensionContext.php

Indentation +53 added lines, -53 removed lines

@@ -61,7 +61,7 @@ 
     public function isSchemaExtended(): bool
     {
         return
-          $this->info->hasTypeExtensionsMap() ||
+            $this->info->hasTypeExtensionsMap() ||
           $this->info->hasTypeDefinitionMap() ||
           $this->info->hasDirectiveDefinitions();
     }
@@ -141,21 +141,21 @@ 
 
         if ($this->info->hasTypeExtensions($typeName)) {
             $extensionASTNodes = $this->extendExtensionASTNodes($typeName,
-              $extensionASTNodes);
+                $extensionASTNodes);
         }
 
         return newObjectType([
-          'name' => $typeName,
-          'description' => $type->getDescription(),
-          'interfaces' => function () use ($type) {
-              return $this->extendImplementedInterfaces($type);
-          },
-          'fields' => function () use ($type) {
-              return $this->extendFieldMap($type);
-          },
-          'astNode' => $type->getAstNode(),
-          'extensionASTNodes' => $extensionASTNodes,
-          'isTypeOf' => $type->getIsTypeOf(),
+            'name' => $typeName,
+            'description' => $type->getDescription(),
+            'interfaces' => function () use ($type) {
+                return $this->extendImplementedInterfaces($type);
+            },
+            'fields' => function () use ($type) {
+                return $this->extendFieldMap($type);
+            },
+            'astNode' => $type->getAstNode(),
+            'extensionASTNodes' => $extensionASTNodes,
+            'isTypeOf' => $type->getIsTypeOf(),
         ]);
     }
 
@@ -166,12 +166,12 @@ 
      * @return array
      */
     protected function extendExtensionASTNodes(
-      string $typeName,
-      array $nodes
+        string $typeName,
+        array $nodes
     ): array {
         $typeExtensions = $this->info->getTypeExtensions($typeName);
         return !empty($nodes) ? \array_merge($typeExtensions,
-          $nodes) : $typeExtensions;
+            $nodes) : $typeExtensions;
     }
 
     /**
@@ -224,15 +224,15 @@ 
             $field = $oldFieldMap[$fieldName];
 
             $newFieldMap[$fieldName] = [
-              'description' => $field->getDescription(),
-              'deprecationReason' => $field->getDeprecationReason(),
-              'type' => $this->extendFieldType($field->getType()),
-              'args' => keyMap($field->getArguments(),
+                'description' => $field->getDescription(),
+                'deprecationReason' => $field->getDeprecationReason(),
+                'type' => $this->extendFieldType($field->getType()),
+                'args' => keyMap($field->getArguments(),
                 function (Argument $argument) {
                     return $argument->getName();
                 }),
-              'astNode' => $field->getAstNode(),
-              'resolve' => $field->getResolve(),
+                'astNode' => $field->getAstNode(),
+                'resolve' => $field->getResolve(),
             ];
         }
 
@@ -246,12 +246,12 @@ 
 
                     if (isset($oldFieldMap[$fieldName])) {
                         throw new ExtensionException(
-                          \sprintf(
+                            \sprintf(
                             'Field "%s.%s" already exists in the schema. ' .
                             'It cannot also be defined in this type extension.',
                             $typeName, $fieldName
-                          ),
-                          [$field]
+                            ),
+                            [$field]
                         );
                     }
 
@@ -296,18 +296,18 @@ 
 
         if ($this->info->hasTypeExtensions($typeName)) {
             $extensionASTNodes = $this->extendExtensionASTNodes($typeName,
-              $extensionASTNodes);
+                $extensionASTNodes);
         }
 
         return newInterfaceType([
-          'name' => $typeName,
-          'description' => $type->getDescription(),
-          'fields' => function () use ($type) {
-              return $this->extendFieldMap($type);
-          },
-          'astNode' => $type->getAstNode(),
-          'extensionASTNodes' => $extensionASTNodes,
-          'resolveType' => $type->getResolveType(),
+            'name' => $typeName,
+            'description' => $type->getDescription(),
+            'fields' => function () use ($type) {
+                return $this->extendFieldMap($type);
+            },
+            'astNode' => $type->getAstNode(),
+            'extensionASTNodes' => $extensionASTNodes,
+            'resolveType' => $type->getResolveType(),
         ]);
     }
 
@@ -320,13 +320,13 @@ 
     protected function extendUnionType(UnionType $type): UnionType
     {
         return newUnionType([
-          'name' => $type->getName(),
-          'description' => $type->getDescription(),
-          'types' => \array_map(function ($unionType) {
-              return $this->getExtendedType($unionType);
-          }, $type->getTypes()),
-          'astNode' => $type->getAstNode(),
-          'resolveType' => $type->getResolveType(),
+            'name' => $type->getName(),
+            'description' => $type->getDescription(),
+            'types' => \array_map(function ($unionType) {
+                return $this->getExtendedType($unionType);
+            }, $type->getTypes()),
+            'astNode' => $type->getAstNode(),
+            'resolveType' => $type->getResolveType(),
         ]);
     }
 
@@ -352,7 +352,7 @@ 
     public function getExtendedSubscriptionType(): ?TypeInterface
     {
         $existingSubscriptionType = $this->info->getSchema()
-          ->getSubscriptionType();
+            ->getSubscriptionType();
 
         return null !== $existingSubscriptionType
           ? $this->getExtendedType($existingSubscriptionType)
@@ -369,8 +369,8 @@ 
         }, $this->info->getSchema()->getTypeMap());
 
         return \array_merge(
-          $extendedTypes,
-          $this->definitionBuilder->buildTypes($this->info->getTypeDefinitionMap())
+            $extendedTypes,
+            $this->definitionBuilder->buildTypes($this->info->getTypeDefinitionMap())
         );
     }
 
@@ -383,13 +383,13 @@ 
         $existingDirectives = $this->info->getSchema()->getDirectives();
 
         invariant(!empty($existingDirectives),
-          'schema must have default directives');
+            'schema must have default directives');
 
         return \array_merge(
-          $existingDirectives,
-          \array_map(function (DirectiveDefinitionNode $node) {
-              return $this->definitionBuilder->buildDirective($node);
-          }, $this->info->getDirectiveDefinitions())
+            $existingDirectives,
+            \array_map(function (DirectiveDefinitionNode $node) {
+                return $this->definitionBuilder->buildDirective($node);
+            }, $this->info->getDirectiveDefinitions())
         );
     }
 
@@ -399,7 +399,7 @@ 
      * @return ExtensionContext
      */
     public function setDefinitionBuilder(
-      DefinitionBuilderInterface $definitionBuilder
+        DefinitionBuilderInterface $definitionBuilder
     ): ExtensionContext {
         $this->definitionBuilder = $definitionBuilder;
         return $this;
@@ -423,12 +423,12 @@ 
         }
 
         throw new ExtensionException(
-          \sprintf(
+            \sprintf(
             'Unknown type: "%s". Ensure that this type exists ' .
             'either in the original schema, or is added in a type definition.',
             $typeName
-          ),
-          [$node]
+            ),
+            [$node]
         );
     }
 }

src/Schema/Validation/SchemaValidator.php

Indentation +4 added lines, -4 removed lines

@@ -21,9 +21,9 @@ 
 
         if (!empty($errors)) {
             $message = \implode("\n",
-              \array_map(function (SchemaValidationException $error) {
-                  return $error->getMessage();
-              }, $errors));
+                \array_map(function (SchemaValidationException $error) {
+                    return $error->getMessage();
+                }, $errors));
 
             throw new SchemaValidationException($message);
         }
@@ -36,7 +36,7 @@ 
      * @return SchemaValidationException[]
      */
     public function validate(
-      SchemaInterface $schema,
+        SchemaInterface $schema,
       ?array $rules = null
     ): array {
         $context = $this->createContext($schema);

src/Schema/Validation/SchemaValidationProvider.php

Indentation +5 added lines, -5 removed lines

@@ -14,10 +14,10 @@ 
      * @var array
      */
     protected $provides = [
-      SchemaValidatorInterface::class,
-      RootTypesRule::class,
-      DirectivesRule::class,
-      TypesRule::class,
+        SchemaValidatorInterface::class,
+        RootTypesRule::class,
+        DirectivesRule::class,
+        TypesRule::class,
     ];
 
     /**
@@ -26,7 +26,7 @@ 
     public function register()
     {
         $this->container->add(SchemaValidatorInterface::class,
-          SchemaValidator::class, true);
+            SchemaValidator::class, true);
 
         // Rules
         $this->container->add(RootTypesRule::class, RootTypesRule::class);

src/Schema/Validation/Rule/TypesRule.php

Indentation +167 added lines, -167 removed lines

@@ -46,11 +46,11 @@ 
         foreach ($typeMap as $type) {
             if (!($type instanceof NamedTypeInterface)) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf('Expected GraphQL named type but got: %s.',
-                      toString($type)),
+                        toString($type)),
                     $type instanceof NodeAwareInterface ? [$type->getAstNode()] : null
-                  )
+                    )
                 );
 
                 continue;
@@ -123,11 +123,11 @@ 
         // Objects and Interfaces both must define one or more fields.
         if (empty($fields)) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 \sprintf('Type %s must define one or more fields.',
-                  $type->getName()),
+                    $type->getName()),
                 $this->getAllObjectOrInterfaceNodes($type)
-              )
+                )
             );
         }
 
@@ -140,11 +140,11 @@ 
 
             if (\count($fieldNodes) > 1) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf('Field %s.%s can only be defined once.',
-                      $type->getName(), $fieldName),
+                        $type->getName(), $fieldName),
                     $fieldNodes
-                  )
+                    )
                 );
 
                 return; // continue loop
@@ -156,15 +156,15 @@ 
             if (!isOutputType($fieldType)) {
                 $fieldTypeNode = $this->getFieldTypeNode($type, $fieldName);
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'The type of %s.%s must be Output Type but got: %s.',
-                      $type->getName(),
-                      $fieldName,
-                      toString($fieldType)
+                        'The type of %s.%s must be Output Type but got: %s.',
+                        $type->getName(),
+                        $fieldName,
+                        toString($fieldType)
                     ),
                     [$fieldTypeNode]
-                  )
+                    )
                 );
             }
 
@@ -180,16 +180,16 @@ 
                 // Ensure they are unique per field.
                 if (isset($argumentNames[$argumentName])) {
                     $this->context->reportError(
-                      new SchemaValidationException(
+                        new SchemaValidationException(
                         \sprintf(
-                          'Field argument %s.%s(%s:) can only be defined once.',
-                          $type->getName(),
-                          $field->getName(),
-                          $argumentName
+                            'Field argument %s.%s(%s:) can only be defined once.',
+                            $type->getName(),
+                            $field->getName(),
+                            $argumentName
                         ),
                         $this->getAllFieldArgumentNodes($type, $fieldName,
-                          $argumentName)
-                      )
+                            $argumentName)
+                        )
                     );
                 }
 
@@ -198,17 +198,17 @@ 
                 // Ensure the type is an input type
                 if (!isInputType($argument->getType())) {
                     $this->context->reportError(
-                      new SchemaValidationException(
+                        new SchemaValidationException(
                         \sprintf(
-                          'The type of %s.%s(%s:) must be Input Type but got: %s.',
-                          $type->getName(),
-                          $fieldName,
-                          $argumentName,
-                          toString($argument->getType())
+                            'The type of %s.%s(%s:) must be Input Type but got: %s.',
+                            $type->getName(),
+                            $fieldName,
+                            $argumentName,
+                            toString($argument->getType())
                         ),
                         $this->getAllFieldArgumentNodes($type, $fieldName,
-                          $argumentName)
-                      )
+                            $argumentName)
+                        )
                     );
                 }
             }
@@ -242,8 +242,8 @@ 
      * @return FieldDefinitionNode[]
      */
     protected function getAllFieldNodes(
-      NamedTypeInterface $type,
-      string $fieldName
+        NamedTypeInterface $type,
+        string $fieldName
     ): array {
         $nodes = [];
 
@@ -265,8 +265,8 @@ 
      * @return TypeNodeInterface|null
      */
     protected function getFieldTypeNode(
-      NamedTypeInterface $type,
-      string $fieldName
+        NamedTypeInterface $type,
+        string $fieldName
     ): ?TypeNodeInterface
     {
         $fieldNode = $this->getFieldNode($type, $fieldName);
@@ -280,8 +280,8 @@ 
      * @return FieldDefinitionNode|null
      */
     protected function getFieldNode(
-      NamedTypeInterface $type,
-      string $fieldName
+        NamedTypeInterface $type,
+        string $fieldName
     ): ?FieldDefinitionNode
     {
         return $this->getAllFieldNodes($type, $fieldName)[0] ?? null;
@@ -295,9 +295,9 @@ 
      * @return InputValueDefinitionNode[]
      */
     protected function getAllFieldArgumentNodes(
-      NamedTypeInterface $type,
-      string $fieldName,
-      string $argumentName
+        NamedTypeInterface $type,
+        string $fieldName,
+        string $argumentName
     ): array {
         $nodes = [];
 
@@ -326,19 +326,19 @@ 
         foreach ($objectType->getInterfaces() as $interface) {
             if (!($interface instanceof InterfaceType)) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'Type %s must only implement Interface types, it cannot implement %s.',
-                      toString($objectType),
-                      toString($interface)
+                        'Type %s must only implement Interface types, it cannot implement %s.',
+                        toString($objectType),
+                        toString($interface)
                     ),
                     null !== $interface
                       ? [
-                      $this->getImplementsInterfaceNode($objectType,
+                        $this->getImplementsInterfaceNode($objectType,
                         $interface->getName()),
                     ]
                       : null
-                  )
+                    )
                 );
 
                 continue;
@@ -348,12 +348,12 @@ 
 
             if (isset($implementedTypeNames[$interfaceName])) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf('Type %s can only implement %s once.',
-                      $objectType->getName(), $interfaceName),
+                        $objectType->getName(), $interfaceName),
                     $this->getAllImplementsInterfaceNodes($objectType,
-                      $interfaceName)
-                  )
+                        $interfaceName)
+                    )
                 );
 
                 continue;
@@ -372,8 +372,8 @@ 
      * @return NamedTypeNode|null
      */
     protected function getImplementsInterfaceNode(
-      ObjectType $type,
-      string $interfaceName
+        ObjectType $type,
+        string $interfaceName
     ): ?NamedTypeNode
     {
         return $this->getAllImplementsInterfaceNodes($type,
@@ -387,8 +387,8 @@ 
      * @return NamedTypeNode[]
      */
     protected function getAllImplementsInterfaceNodes(
-      ObjectType $type,
-      string $interfaceName
+        ObjectType $type,
+        string $interfaceName
     ): array {
         $nodes = [];
 
@@ -410,8 +410,8 @@ 
      * @throws InvariantException
      */
     protected function validateObjectImplementsInterface(
-      ObjectType $objectType,
-      InterfaceType $interfaceType
+        ObjectType $objectType,
+        InterfaceType $interfaceType
     ): void {
         $objectFields = $objectType->getFields();
         $interfaceFields = $interfaceType->getFields();
@@ -424,18 +424,18 @@ 
             // Assert interface field exists on object.
             if (null === $objectField) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'Interface field %s.%s expected but %s does not provide it.',
-                      $interfaceType->getName(),
-                      $fieldName,
-                      $objectType->getName()
+                        'Interface field %s.%s expected but %s does not provide it.',
+                        $interfaceType->getName(),
+                        $fieldName,
+                        $objectType->getName()
                     ),
                     [
-                      $this->getFieldNode($interfaceType, $fieldName),
-                      $objectType->getAstNode(),
+                        $this->getFieldNode($interfaceType, $fieldName),
+                        $objectType->getAstNode(),
                     ]
-                  )
+                    )
                 );
 
                 continue;
@@ -444,24 +444,24 @@ 
             // Assert interface field type is satisfied by object field type, by being
             // a valid subtype. (covariant)
             if (!isTypeSubtypeOf(
-              $this->context->getSchema(), $objectField->getType(),
-              $interfaceField->getType())) {
+                $this->context->getSchema(), $objectField->getType(),
+                $interfaceField->getType())) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'Interface field %s.%s expects type %s but %s.%s is type %s.',
-                      $interfaceType->getName(),
-                      $fieldName,
-                      toString($interfaceField->getType()),
-                      $objectType->getName(),
-                      $fieldName,
-                      toString($objectField->getType())
+                        'Interface field %s.%s expects type %s but %s.%s is type %s.',
+                        $interfaceType->getName(),
+                        $fieldName,
+                        toString($interfaceField->getType()),
+                        $objectType->getName(),
+                        $fieldName,
+                        toString($objectField->getType())
                     ),
                     [
-                      $this->getFieldTypeNode($interfaceType, $fieldName),
-                      $this->getFieldTypeNode($objectType, $fieldName),
+                        $this->getFieldTypeNode($interfaceType, $fieldName),
+                        $this->getFieldTypeNode($objectType, $fieldName),
                     ]
-                  )
+                    )
                 );
             }
 
@@ -469,28 +469,28 @@ 
             foreach ($interfaceField->getArguments() as $interfaceArgument) {
                 $argumentName = $interfaceArgument->getName();
                 $objectArgument = find($objectField->getArguments(),
-                  function (Argument $argument) use ($argumentName) {
-                      return $argument->getName() === $argumentName;
-                  });
+                    function (Argument $argument) use ($argumentName) {
+                        return $argument->getName() === $argumentName;
+                    });
 
                 // Assert interface field arg exists on object field.
                 if (null === $objectArgument) {
                     $this->context->reportError(
-                      new SchemaValidationException(
+                        new SchemaValidationException(
                         \sprintf(
-                          'Interface field argument %s.%s(%s:) expected but %s.%s does not provide it.',
-                          $interfaceType->getName(),
-                          $fieldName,
-                          $argumentName,
-                          $objectType->getName(),
-                          $fieldName
+                            'Interface field argument %s.%s(%s:) expected but %s.%s does not provide it.',
+                            $interfaceType->getName(),
+                            $fieldName,
+                            $argumentName,
+                            $objectType->getName(),
+                            $fieldName
                         ),
                         [
-                          $this->getFieldArgumentNode($interfaceType,
+                            $this->getFieldArgumentNode($interfaceType,
                             $fieldName, $argumentName),
-                          $this->getFieldNode($objectType, $fieldName),
+                            $this->getFieldNode($objectType, $fieldName),
                         ]
-                      )
+                        )
                     );
 
                     continue;
@@ -500,27 +500,27 @@ 
                 // (invariant)
                 // TODO: change to contravariant?
                 if (!isEqualType($interfaceArgument->getType(),
-                  $objectArgument->getType())) {
+                    $objectArgument->getType())) {
                     $this->context->reportError(
-                      new SchemaValidationException(
+                        new SchemaValidationException(
                         \sprintf(
-                          'Interface field argument %s.%s(%s:) expects type %s but %s.%s(%s:) is type %s.',
-                          $interfaceType->getName(),
-                          $fieldName,
-                          $argumentName,
-                          toString($interfaceArgument->getType()),
-                          $objectType->getName(),
-                          $fieldName,
-                          $argumentName,
-                          toString($objectArgument->getType())
+                            'Interface field argument %s.%s(%s:) expects type %s but %s.%s(%s:) is type %s.',
+                            $interfaceType->getName(),
+                            $fieldName,
+                            $argumentName,
+                            toString($interfaceArgument->getType()),
+                            $objectType->getName(),
+                            $fieldName,
+                            $argumentName,
+                            toString($objectArgument->getType())
                         ),
                         [
-                          $this->getFieldArgumentTypeNode($interfaceType,
+                            $this->getFieldArgumentTypeNode($interfaceType,
                             $fieldName, $argumentName),
-                          $this->getFieldArgumentTypeNode($objectType,
+                            $this->getFieldArgumentTypeNode($objectType,
                             $fieldName, $argumentName),
                         ]
-                      )
+                        )
                     );
 
                     continue;
@@ -531,31 +531,31 @@ 
                 foreach ($objectField->getArguments() as $objectArgument) {
                     $argumentName = $objectArgument->getName();
                     $interfaceArgument = find(
-                      $interfaceField->getArguments(),
-                      function (Argument $argument) use ($argumentName) {
-                          return $argument->getName() === $argumentName;
-                      }
+                        $interfaceField->getArguments(),
+                        function (Argument $argument) use ($argumentName) {
+                            return $argument->getName() === $argumentName;
+                        }
                     );
 
                     if (null === $interfaceArgument && $objectArgument->getType() instanceof NonNullType) {
                         $this->context->reportError(
-                          new SchemaValidationException(
+                            new SchemaValidationException(
                             \sprintf(
-                              'Object field argument %s.%s(%s:) is of required type %s ' .
-                              'but is not also provided by the Interface field %s.%s.',
-                              $objectType->getName(),
-                              $fieldName,
-                              $argumentName,
-                              toString($objectArgument->getType()),
-                              $interfaceType->getName(),
-                              $fieldName
+                                'Object field argument %s.%s(%s:) is of required type %s ' .
+                                'but is not also provided by the Interface field %s.%s.',
+                                $objectType->getName(),
+                                $fieldName,
+                                $argumentName,
+                                toString($objectArgument->getType()),
+                                $interfaceType->getName(),
+                                $fieldName
                             ),
                             [
-                              $this->getFieldArgumentNode($objectType,
+                                $this->getFieldArgumentNode($objectType,
                                 $fieldName, $argumentName),
-                              $this->getFieldNode($interfaceType, $fieldName),
+                                $this->getFieldNode($interfaceType, $fieldName),
                             ]
-                          )
+                            )
                         );
 
                         continue;
@@ -573,9 +573,9 @@ 
      * @return InputValueDefinitionNode|null
      */
     protected function getFieldArgumentNode(
-      NamedTypeInterface $type,
-      string $fieldName,
-      string $argumentName
+        NamedTypeInterface $type,
+        string $fieldName,
+        string $argumentName
     ): ?InputValueDefinitionNode
     {
         return $this->getAllFieldArgumentNodes($type, $fieldName,
@@ -590,9 +590,9 @@ 
      * @return TypeNodeInterface|null
      */
     protected function getFieldArgumentTypeNode(
-      NamedTypeInterface $type,
-      string $fieldName,
-      string $argumentName
+        NamedTypeInterface $type,
+        string $fieldName,
+        string $argumentName
     ): ?TypeNodeInterface
     {
         $node = $this->getFieldArgumentNode($type, $fieldName, $argumentName);
@@ -611,11 +611,11 @@ 
 
         if (empty($memberTypes)) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 sprintf('Union type %s must define one or more member types.',
-                  $unionType->getName()),
+                    $unionType->getName()),
                 [$unionType->getAstNode()]
-              )
+                )
             );
         }
 
@@ -625,14 +625,14 @@ 
             $memberTypeName = $memberType->getName();
             if (isset($includedTypeNames[$memberTypeName])) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'Union type %s can only include type %s once.',
-                      $unionType->getName(),
-                      $memberTypeName
+                        'Union type %s can only include type %s once.',
+                        $unionType->getName(),
+                        $memberTypeName
                     ),
                     $this->getUnionMemberTypeNodes($unionType, $memberTypeName)
-                  )
+                    )
                 );
 
                 continue;
@@ -642,17 +642,17 @@ 
 
             if (!($memberType instanceof ObjectType)) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'Union type %s can only include Object types, it cannot include %s.',
-                      $unionType->getName(),
-                      toString($memberType)
+                        'Union type %s can only include Object types, it cannot include %s.',
+                        $unionType->getName(),
+                        toString($memberType)
                     ),
                     null !== $memberTypeName
                       ? $this->getUnionMemberTypeNodes($unionType,
-                      $memberTypeName)
+                        $memberTypeName)
                       : null
-                  )
+                    )
                 );
             }
         }
@@ -665,8 +665,8 @@ 
      * @return array|null
      */
     protected function getUnionMemberTypeNodes(
-      UnionType $unionType,
-      string $memberTypeName
+        UnionType $unionType,
+        string $memberTypeName
     ): ?array
     {
         /** @var UnionTypeDefinitionNode $node */
@@ -677,9 +677,9 @@ 
         }
 
         return \array_filter($node->getTypes(),
-          function (NamedTypeNode $type) use ($memberTypeName) {
-              return $type->getNameValue() === $memberTypeName;
-          });
+            function (NamedTypeNode $type) use ($memberTypeName) {
+                return $type->getNameValue() === $memberTypeName;
+            });
     }
 
     /**
@@ -694,11 +694,11 @@ 
 
         if (empty($enumValues)) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 \sprintf('Enum type %s must define one or more values.',
-                  $enumType->getName()),
+                    $enumType->getName()),
                 [$enumType->getAstNode()]
-              )
+                )
             );
         }
 
@@ -710,11 +710,11 @@ 
 
             if (null !== $allNodes && \count($allNodes) > 1) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     sprintf('Enum type %s can include value %s only once.',
-                      $enumType->getName(), $valueName),
+                        $enumType->getName(), $valueName),
                     $allNodes
-                  )
+                    )
                 );
 
                 continue;
@@ -725,11 +725,11 @@ 
 
             if ($valueName === 'true' || $valueName === 'false' || $valueName === 'null') {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     sprintf('Enum type %s cannot include value: %s.',
-                      $enumType->getName(), $valueName),
+                        $enumType->getName(), $valueName),
                     [$enumValue->getAstNode()]
-                  )
+                    )
                 );
 
                 continue;
@@ -744,8 +744,8 @@ 
      * @return array|null
      */
     protected function getEnumValueNodes(
-      EnumType $enumType,
-      string $valueName
+        EnumType $enumType,
+        string $valueName
     ): ?array
     {
         /** @var EnumTypeDefinitionNode $node */
@@ -756,9 +756,9 @@ 
         }
 
         return \array_filter($node->getValues(),
-          function (NameAwareInterface $type) use ($valueName) {
-              return $type->getNameValue() === $valueName;
-          });
+            function (NameAwareInterface $type) use ($valueName) {
+                return $type->getNameValue() === $valueName;
+            });
     }
 
     /**
@@ -773,11 +773,11 @@ 
 
         if (empty($fields)) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 \sprintf('Input Object type %s must define one or more fields.',
-                  $inputObjectType->getName()),
+                    $inputObjectType->getName()),
                 [$inputObjectType->getAstNode()]
-              )
+                )
             );
         }
 
@@ -791,15 +791,15 @@ 
             // Ensure the type is an input type
             if (!isInputType($field->getType())) {
                 $this->context->reportError(
-                  new SchemaValidationException(
+                    new SchemaValidationException(
                     \sprintf(
-                      'The type of %s.%s must be Input Type but got: %s.',
-                      $inputObjectType->getName(),
-                      $fieldName,
-                      toString($field->getType())
+                        'The type of %s.%s must be Input Type but got: %s.',
+                        $inputObjectType->getName(),
+                        $fieldName,
+                        toString($field->getType())
                     ),
                     [$field->getAstNode()]
-                  )
+                    )
                 );
             }
         }