digiaonline / graphql-php

src/Schema/Validation/Rule/SupportedRules.php

Indentation +3 added lines, -3 removed lines

@@ -11,9 +11,9 @@
      * @var array
      */
     private static $supportedRules = [
-      RootTypesRule::class,
-      DirectivesRule::class,
-      TypesRule::class,
+        RootTypesRule::class,
+        DirectivesRule::class,
+        TypesRule::class,
     ];
 
     /**

src/Schema/Validation/Rule/RootTypesRule.php

Indentation +21 added lines, -21 removed lines

@@ -22,9 +22,9 @@ 
         $schema = $this->context->getSchema();
 
         $rootTypes = [
-          'query' => $schema->getQueryType(),
-          'mutation' => $schema->getMutationType(),
-          'subscription' => $schema->getSubscriptionType(),
+            'query' => $schema->getQueryType(),
+            'mutation' => $schema->getMutationType(),
+            'subscription' => $schema->getSubscriptionType(),
         ];
 
         foreach ($rootTypes as $operation => $rootType) {
@@ -38,17 +38,17 @@ 
      */
     protected function validateRootType(
       ?TypeInterface $rootType,
-      string $operation
+        string $operation
     ): void {
         $schema = $this->context->getSchema();
 
         if ($operation === 'query' && null === $rootType) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 \sprintf('%s root type must be provided.',
-                  \ucfirst($operation)),
+                    \ucfirst($operation)),
                 $schema->hasAstNode() ? [$schema->getAstNode()] : null
-              )
+                )
             );
 
             return;
@@ -56,18 +56,18 @@ 
 
         if (null !== $rootType && !($rootType instanceof ObjectType)) {
             $this->context->reportError(
-              new SchemaValidationException(
+                new SchemaValidationException(
                 \sprintf(
-                  $operation === 'query'
+                    $operation === 'query'
                     ? '%s root type must be Object type, it cannot be %s.'
                     : '%s root type must be Object type if provided, it cannot be %s.',
-                  \ucfirst($operation),
-                  (string)$rootType
+                    \ucfirst($operation),
+                    (string)$rootType
                 ),
                 null !== $rootType ? [
-                  $this->getOperationTypeNode($schema, $rootType, $operation),
+                    $this->getOperationTypeNode($schema, $rootType, $operation),
                 ] : null
-              )
+                )
             );
 
             return;
@@ -82,9 +82,9 @@ 
      * @return NodeInterface|null
      */
     protected function getOperationTypeNode(
-      SchemaInterface $schema,
-      TypeInterface $type,
-      string $operation
+        SchemaInterface $schema,
+        TypeInterface $type,
+        string $operation
     ): ?NodeInterface
     {
         /** @var SchemaDefinitionNode $node */
@@ -96,11 +96,11 @@ 
 
         /** @var OperationTypeDefinitionNode $operationTypeNode */
         $operationTypeNode = find(
-          $node->getOperationTypes(),
-          function (OperationTypeDefinitionNode $operationType) use ($operation
-          ) {
-              return $operationType->getOperation() === $operation;
-          }
+            $node->getOperationTypes(),
+            function (OperationTypeDefinitionNode $operationType) use ($operation
+            ) {
+                return $operationType->getOperation() === $operation;
+            }
         );
 
         return $operationTypeNode->getType();

Spacing +1 added lines, -1 removed lines

@@ -97,7 +97,7 @@
         /** @var OperationTypeDefinitionNode $operationTypeNode */
         $operationTypeNode = find(
           $node->getOperationTypes(),
-          function (OperationTypeDefinitionNode $operationType) use ($operation
+          function(OperationTypeDefinitionNode $operationType) use ($operation
           ) {
               return $operationType->getOperation() === $operation;
           }

src/Schema/Validation/SchemaValidatorInterface.php

Indentation +1 added lines, -1 removed lines

@@ -16,7 +16,7 @@
      * @return SchemaValidationException[]
      */
     public function validate(
-      SchemaInterface $schema,
+        SchemaInterface $schema,
       ?array $rules = null
     ): array;
 

src/Schema/Schema.php

Indentation +30 added lines, -30 removed lines

@@ -137,9 +137,9 @@ 
     public function getDirective(string $name): ?Directive
     {
         return find($this->directives,
-          function (Directive $directive) use ($name) {
-              return $directive->getName() === $name;
-          });
+            function (Directive $directive) use ($name) {
+                return $directive->getName() === $name;
+            });
     }
 
     /**
@@ -192,8 +192,8 @@ 
      * @inheritdoc
      */
     public function isPossibleType(
-      AbstractTypeInterface $abstractType,
-      TypeInterface $possibleType
+        AbstractTypeInterface $abstractType,
+        TypeInterface $possibleType
     ): bool {
         /** @noinspection PhpUndefinedMethodInspection */
         $abstractTypeName = $abstractType->getName();
@@ -204,21 +204,21 @@ 
             $possibleTypes = $this->getPossibleTypes($abstractType);
 
             invariant(
-              \is_array($possibleTypes),
-              \sprintf(
+                \is_array($possibleTypes),
+                \sprintf(
                 'Could not find possible implementing types for %s ' .
                 'in schema. Check that schema.types is defined and is an array of ' .
                 'all possible types in the schema.',
                 $abstractTypeName
-              )
+                )
             );
 
             $this->possibleTypesMap[$abstractTypeName] = \array_reduce($possibleTypes,
-              function (array $map, TypeInterface $type) {
-                  /** @var NameAwareInterface $type */
-                  $map[$type->getName()] = true;
-                  return $map;
-              }, []);
+                function (array $map, TypeInterface $type) {
+                    /** @var NameAwareInterface $type */
+                    $map[$type->getName()] = true;
+                    return $map;
+                }, []);
         }
 
         return isset($this->possibleTypesMap[$abstractTypeName][$possibleTypeName]);
@@ -268,10 +268,10 @@ 
     protected function buildTypeMap(): void
     {
         $initialTypes = [
-          $this->query,
-          $this->mutation,
-          $this->subscription,
-          __Schema(), // Introspection
+            $this->query,
+            $this->mutation,
+            $this->subscription,
+            __Schema(), // Introspection
         ];
 
         if ($this->types) {
@@ -283,11 +283,11 @@ 
 
         // First by deeply visiting all initial types.
         $typeMap = \array_reduce($initialTypes, [$this, 'typeMapReducer'],
-          $typeMap);
+            $typeMap);
 
         // Then by deeply visiting all directive types.
         $typeMap = \array_reduce($this->directives,
-          [$this, 'typeMapDirectiveReducer'], $typeMap);
+            [$this, 'typeMapDirectiveReducer'], $typeMap);
 
         // Storing the resulting map for reference by the schema.
         $this->typeMap = $typeMap;
@@ -383,9 +383,9 @@ 
         }
 
         return \array_reduce($directive->getArguments(),
-          function ($map, Argument $argument) {
-              return $this->typeMapReducer($map, $argument->getType());
-          }, $map);
+            function ($map, Argument $argument) {
+                return $this->typeMapReducer($map, $argument->getType());
+            }, $map);
     }
 
     /**
@@ -409,11 +409,11 @@ 
 
         if (isset($map[$typeName])) {
             invariant(
-              $type === $map[$typeName],
-              \sprintf(
+                $type === $map[$typeName],
+                \sprintf(
                 'Schema must contain unique named types but contains multiple types named "%s".',
                 $type->getName()
-              )
+                )
             );
 
             return $map;
@@ -425,12 +425,12 @@ 
 
         if ($type instanceof UnionType) {
             $reducedMap = \array_reduce($type->getTypes(),
-              [$this, 'typeMapReducer'], $reducedMap);
+                [$this, 'typeMapReducer'], $reducedMap);
         }
 
         if ($type instanceof ObjectType) {
             $reducedMap = \array_reduce($type->getInterfaces(),
-              [$this, 'typeMapReducer'], $reducedMap);
+                [$this, 'typeMapReducer'], $reducedMap);
         }
 
         if ($type instanceof ObjectType || $type instanceof InterfaceType) {
@@ -441,18 +441,18 @@ 
                     }, $field->getArguments());
 
                     $reducedMap = \array_reduce($fieldArgTypes,
-                      [$this, 'typeMapReducer'], $reducedMap);
+                        [$this, 'typeMapReducer'], $reducedMap);
                 }
 
                 $reducedMap = $this->typeMapReducer($reducedMap,
-                  $field->getType());
+                    $field->getType());
             }
         }
 
         if ($type instanceof InputObjectType) {
             foreach ($type->getFields() as $field) {
                 $reducedMap = $this->typeMapReducer($reducedMap,
-                  $field->getType());
+                    $field->getType());
             }
         }
 

Spacing +4 added lines, -4 removed lines

@@ -137,7 +137,7 @@ 
     public function getDirective(string $name): ?Directive
     {
         return find($this->directives,
-          function (Directive $directive) use ($name) {
+          function(Directive $directive) use ($name) {
               return $directive->getName() === $name;
           });
     }
@@ -214,7 +214,7 @@ 
             );
 
             $this->possibleTypesMap[$abstractTypeName] = \array_reduce($possibleTypes,
-              function (array $map, TypeInterface $type) {
+              function(array $map, TypeInterface $type) {
                   /** @var NameAwareInterface $type */
                   $map[$type->getName()] = true;
                   return $map;
@@ -383,7 +383,7 @@ 
         }
 
         return \array_reduce($directive->getArguments(),
-          function ($map, Argument $argument) {
+          function($map, Argument $argument) {
               return $this->typeMapReducer($map, $argument->getType());
           }, $map);
     }
@@ -436,7 +436,7 @@ 
         if ($type instanceof ObjectType || $type instanceof InterfaceType) {
             foreach ($type->getFields() as $field) {
                 if ($field->hasArguments()) {
-                    $fieldArgTypes = \array_map(function (Argument $argument) {
+                    $fieldArgTypes = \array_map(function(Argument $argument) {
                         return $argument->getType();
                     }, $field->getArguments());
 

src/Schema/Building/BuildInfo.php

Indentation +4 added lines, -4 removed lines

@@ -48,10 +48,10 @@
      * @param SchemaDefinitionNode|null $schemaDefinition
      */
     public function __construct(
-      DocumentNode $document,
-      array $typeDefinitionMap,
-      array $directiveDefinitions,
-      array $operationTypeDefinitions,
+        DocumentNode $document,
+        array $typeDefinitionMap,
+        array $directiveDefinitions,
+        array $operationTypeDefinitions,
       ?SchemaDefinitionNode $schemaDefinition = null
     ) {
         $this->document = $document;

src/Schema/Building/SchemaBuilder.php

Indentation +27 added lines, -27 removed lines

@@ -37,20 +37,20 @@ 
      * @inheritdoc
      */
     public function build(
-      DocumentNode $document,
-      ResolverRegistryInterface $resolverRegistry,
-      array $options = []
+        DocumentNode $document,
+        ResolverRegistryInterface $resolverRegistry,
+        array $options = []
     ): SchemaInterface {
         $context = $this->createContext($document, $resolverRegistry);
 
         return newSchema([
-          'query' => $context->buildQueryType(),
-          'mutation' => $context->buildMutationType(),
-          'subscription' => $context->buildSubscriptionType(),
-          'types' => $context->buildTypes(),
-          'directives' => $context->buildDirectives(),
-          'astNode' => $context->getSchemaDefinition(),
-          'assumeValid' => $options['assumeValid'] ?? false,
+            'query' => $context->buildQueryType(),
+            'mutation' => $context->buildMutationType(),
+            'subscription' => $context->buildSubscriptionType(),
+            'types' => $context->buildTypes(),
+            'directives' => $context->buildDirectives(),
+            'astNode' => $context->getSchemaDefinition(),
+            'assumeValid' => $options['assumeValid'] ?? false,
         ]);
     }
 
@@ -58,20 +58,20 @@ 
      * @inheritdoc
      */
     public function createContext(
-      DocumentNode $document,
-      ResolverRegistryInterface $resolverRegistry
+        DocumentNode $document,
+        ResolverRegistryInterface $resolverRegistry
     ): BuildingContextInterface {
         $info = $this->createInfo($document);
 
         $definitionBuilder = new DefinitionBuilder(
-          $info->getTypeDefinitionMap(),
-          $resolverRegistry,
-          null, // use the default resolveType-function
-          $this->cache
+            $info->getTypeDefinitionMap(),
+            $resolverRegistry,
+            null, // use the default resolveType-function
+            $this->cache
         );
 
         return new BuildingContext($resolverRegistry, $definitionBuilder,
-          $info);
+            $info);
     }
 
     /**
@@ -100,7 +100,7 @@ 
 
                 if (isset($typeDefinitionMap[$typeName])) {
                     throw new BuildingException(sprintf('Type "%s" was defined more than once.',
-                      $typeName));
+                        $typeName));
                 }
 
                 $typeDefinitionMap[$typeName] = $definition;
@@ -116,12 +116,12 @@ 
         }
 
         return new BuildInfo(
-          $document,
-          $typeDefinitionMap,
-          $directiveDefinitions,
-          null !== $schemaDefinition ? $this->getOperationTypeDefinitions($schemaDefinition,
+            $document,
+            $typeDefinitionMap,
+            $directiveDefinitions,
+            null !== $schemaDefinition ? $this->getOperationTypeDefinitions($schemaDefinition,
             $typeDefinitionMap) : [],
-          $schemaDefinition
+            $schemaDefinition
         );
     }
 
@@ -132,8 +132,8 @@ 
      * @throws BuildingException
      */
     protected function getOperationTypeDefinitions(
-      SchemaDefinitionNode $node,
-      array $typeDefinitionMap
+        SchemaDefinitionNode $node,
+        array $typeDefinitionMap
     ): array {
         $definitions = [];
 
@@ -145,14 +145,14 @@ 
 
             if (isset($definitions[$typeName])) {
                 throw new BuildingException(
-                  \sprintf('Must provide only one %s type in schema.',
+                    \sprintf('Must provide only one %s type in schema.',
                     $operation)
                 );
             }
 
             if (!isset($typeDefinitionMap[$typeName])) {
                 throw new BuildingException(
-                  \sprintf('Specified %s type %s not found in document.',
+                    \sprintf('Specified %s type %s not found in document.',
                     $operation, $typeName)
                 );
             }

src/Schema/Building/SchemaBuildingProvider.php

Indentation +3 added lines, -3 removed lines

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

src/Schema/Building/BuildingContext.php

Indentation +9 added lines, -9 removed lines

@@ -37,9 +37,9 @@ 
      * @param BuildInfo $info
      */
     public function __construct(
-      ResolverRegistryInterface $resolverRegistry,
-      DefinitionBuilderInterface $definitionBuilder,
-      BuildInfo $info
+        ResolverRegistryInterface $resolverRegistry,
+        DefinitionBuilderInterface $definitionBuilder,
+        BuildInfo $info
     ) {
         $this->resolverRegistry = $resolverRegistry;
         $this->definitionBuilder = $definitionBuilder;
@@ -94,16 +94,16 @@ 
         }, $this->info->getDirectiveDefinitions());
 
         $specifiedDirectivesMap = [
-          'skip' => SkipDirective(),
-          'include' => IncludeDirective(),
-          'deprecated' => DeprecatedDirective(),
+            'skip' => SkipDirective(),
+            'include' => IncludeDirective(),
+            'deprecated' => DeprecatedDirective(),
         ];
 
         foreach ($specifiedDirectivesMap as $name => $directive) {
             if (!arraySome($directives,
-              function (Directive $directive) use ($name) {
-                  return $directive->getName() === $name;
-              })) {
+                function (Directive $directive) use ($name) {
+                    return $directive->getName() === $name;
+                })) {
                 $directives[] = $directive;
             }
         }

Spacing +3 added lines, -3 removed lines

@@ -78,7 +78,7 @@ 
      */
     public function buildTypes(): array
     {
-        return \array_map(function (TypeDefinitionNodeInterface $definition) {
+        return \array_map(function(TypeDefinitionNodeInterface $definition) {
             return $this->definitionBuilder->buildType($definition);
         }, \array_values($this->info->getTypeDefinitionMap()));
     }
@@ -88,7 +88,7 @@ 
      */
     public function buildDirectives(): array
     {
-        $directives = \array_map(function (DirectiveDefinitionNode $definition
+        $directives = \array_map(function(DirectiveDefinitionNode $definition
         ) {
             return $this->definitionBuilder->buildDirective($definition);
         }, $this->info->getDirectiveDefinitions());
@@ -101,7 +101,7 @@ 
 
         foreach ($specifiedDirectivesMap as $name => $directive) {
             if (!arraySome($directives,
-              function (Directive $directive) use ($name) {
+              function(Directive $directive) use ($name) {
                   return $directive->getName() === $name;
               })) {
                 $directives[] = $directive;

src/Schema/Building/SchemaBuilderInterface.php

Indentation +5 added lines, -5 removed lines

@@ -17,9 +17,9 @@ 
      * @return SchemaInterface
      */
     public function build(
-      DocumentNode $document,
-      ResolverRegistryInterface $resolverRegistry,
-      array $options = []
+        DocumentNode $document,
+        ResolverRegistryInterface $resolverRegistry,
+        array $options = []
     ): SchemaInterface;
 
     /**
@@ -29,7 +29,7 @@ 
      * @return BuildingContextInterface
      */
     public function createContext(
-      DocumentNode $document,
-      ResolverRegistryInterface $resolverRegistry
+        DocumentNode $document,
+        ResolverRegistryInterface $resolverRegistry
     ): BuildingContextInterface;
 }