digiaonline / graphql-php

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
-          );
+            );
     }
 
     /**

src/Type/IntrospectionProvider.php

Indentation +259 added lines, -259 removed lines

@@ -30,18 +30,18 @@ 
      */
     protected $provides = [
         // Introspection types
-      GraphQL::SCHEMA_INTROSPECTION,
-      GraphQL::DIRECTIVE_INTROSPECTION,
-      GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
-      GraphQL::TYPE_INTROSPECTION,
-      GraphQL::FIELD_INTROSPECTION,
-      GraphQL::INPUT_VALUE_INTROSPECTION,
-      GraphQL::ENUM_VALUE_INTROSPECTION,
-      GraphQL::TYPE_KIND_INTROSPECTION,
+        GraphQL::SCHEMA_INTROSPECTION,
+        GraphQL::DIRECTIVE_INTROSPECTION,
+        GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
+        GraphQL::TYPE_INTROSPECTION,
+        GraphQL::FIELD_INTROSPECTION,
+        GraphQL::INPUT_VALUE_INTROSPECTION,
+        GraphQL::ENUM_VALUE_INTROSPECTION,
+        GraphQL::TYPE_KIND_INTROSPECTION,
         // Meta fields
-      GraphQL::SCHEMA_META_FIELD_DEFINITION,
-      GraphQL::TYPE_META_FIELD_DEFINITION,
-      GraphQL::TYPE_NAME_META_FIELD_DEFINITION,
+        GraphQL::SCHEMA_META_FIELD_DEFINITION,
+        GraphQL::TYPE_META_FIELD_DEFINITION,
+        GraphQL::TYPE_NAME_META_FIELD_DEFINITION,
     ];
 
     /**
@@ -60,163 +60,163 @@ 
     {
         $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::SCHEMA_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::SCHEMA_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'A GraphQL Schema defines the capabilities of a GraphQL server. It ' .
                 'exposes all available types and directives on the server, as well as ' .
                 'the entry points for query, mutation, and subscription operations.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'types' => [
-                      'description' => 'A list of all types supported by this server.',
-                      'type' => newNonNull(newList(newNonNull(__Type()))),
-                      'resolve' => function (SchemaInterface $schema): array {
-                          return array_values($schema->getTypeMap());
-                      },
+                        'description' => 'A list of all types supported by this server.',
+                        'type' => newNonNull(newList(newNonNull(__Type()))),
+                        'resolve' => function (SchemaInterface $schema): array {
+                            return array_values($schema->getTypeMap());
+                        },
                     ],
                     'queryType' => [
-                      'description' => 'The type that query operations will be rooted at.',
-                      'type' => newNonNull(__Type()),
-                      'resolve' => function (SchemaInterface $schema
-                      ): ?TypeInterface {
-                          return $schema->getQueryType();
-                      },
+                        'description' => 'The type that query operations will be rooted at.',
+                        'type' => newNonNull(__Type()),
+                        'resolve' => function (SchemaInterface $schema
+                        ): ?TypeInterface {
+                            return $schema->getQueryType();
+                        },
                     ],
                     'mutationType' => [
-                      'description' =>
+                        'description' =>
                         'If this server supports mutation, the type that ' .
                         'mutation operations will be rooted at.',
-                      'type' => __Type(),
-                      'resolve' => function (SchemaInterface $schema
-                      ): ?TypeInterface {
-                          return $schema->getMutationType();
-                      },
+                        'type' => __Type(),
+                        'resolve' => function (SchemaInterface $schema
+                        ): ?TypeInterface {
+                            return $schema->getMutationType();
+                        },
                     ],
                     'subscriptionType' => [
-                      'description' =>
+                        'description' =>
                         'If this server support subscription, the type that ' .
                         'subscription operations will be rooted at.',
-                      'type' => __Type(),
-                      'resolve' => function (SchemaInterface $schema
-                      ): ?TypeInterface {
-                          return $schema->getSubscriptionType();
-                      },
+                        'type' => __Type(),
+                        'resolve' => function (SchemaInterface $schema
+                        ): ?TypeInterface {
+                            return $schema->getSubscriptionType();
+                        },
                     ],
                     'directives' => [
-                      'description' => 'A list of all directives supported by this server.',
-                      'type' => newNonNull(newList(newNonNull(__Directive()))),
-                      'resolve' => function (SchemaInterface $schema): array {
-                          return $schema->getDirectives();
-                      },
-                    ],
-                  ];
-              },
+                        'description' => 'A list of all directives supported by this server.',
+                        'type' => newNonNull(newList(newNonNull(__Directive()))),
+                        'resolve' => function (SchemaInterface $schema): array {
+                            return $schema->getDirectives();
+                        },
+                    ],
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::DIRECTIVE_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::DIRECTIVE_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'A Directive provides a way to describe alternate runtime execution and ' .
                 'type validation behavior in a GraphQL document.' .
                 "\n\nIn some cases, you need to provide options to alter GraphQL's " .
                 'execution behavior in ways field arguments will not suffice, such as ' .
                 'conditionally including or skipping a field. Directives provide this by ' .
                 'describing additional information to the executor.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
                     'locations' => [
-                      'type' => newNonNull(newList(newNonNull(__DirectiveLocation()))),
+                        'type' => newNonNull(newList(newNonNull(__DirectiveLocation()))),
                     ],
                     'args' => [
-                      'type' => newNonNull(newList(newNonNull(__InputValue()))),
-                      'resolve' => function (DirectiveInterface $directive
-                      ): array {
-                          return $directive->getArguments() ?: [];
-                      },
-                    ],
-                  ];
-              },
+                        'type' => newNonNull(newList(newNonNull(__InputValue()))),
+                        'resolve' => function (DirectiveInterface $directive
+                        ): array {
+                            return $directive->getArguments() ?: [];
+                        },
+                    ],
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
-          function () {
-              return newEnumType([
+            function () {
+                return newEnumType([
                 'name' => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                 'isIntrospection' => true,
                 'description' =>
-                  'A Directive can be adjacent to many parts of the GraphQL language, a ' .
-                  '__DirectiveLocation describes one such possible adjacencies.',
+                    'A Directive can be adjacent to many parts of the GraphQL language, a ' .
+                    '__DirectiveLocation describes one such possible adjacencies.',
                 'values' => [
-                  DirectiveLocationEnum::QUERY => [
+                    DirectiveLocationEnum::QUERY => [
                     'description' => 'Location adjacent to a query operation.',
-                  ],
-                  DirectiveLocationEnum::MUTATION => [
+                    ],
+                    DirectiveLocationEnum::MUTATION => [
                     'description' => 'Location adjacent to a mutation operation.',
-                  ],
-                  DirectiveLocationEnum::SUBSCRIPTION => [
+                    ],
+                    DirectiveLocationEnum::SUBSCRIPTION => [
                     'description' => 'Location adjacent to a subscription operation.',
-                  ],
-                  DirectiveLocationEnum::FIELD => [
+                    ],
+                    DirectiveLocationEnum::FIELD => [
                     'description' => 'Location adjacent to a field.',
-                  ],
-                  DirectiveLocationEnum::FRAGMENT_DEFINITION => [
+                    ],
+                    DirectiveLocationEnum::FRAGMENT_DEFINITION => [
                     'description' => 'Location adjacent to a fragment definition.',
-                  ],
-                  DirectiveLocationEnum::FRAGMENT_SPREAD => [
+                    ],
+                    DirectiveLocationEnum::FRAGMENT_SPREAD => [
                     'description' => 'Location adjacent to a fragment spread.',
-                  ],
-                  DirectiveLocationEnum::INLINE_FRAGMENT => [
+                    ],
+                    DirectiveLocationEnum::INLINE_FRAGMENT => [
                     'description' => 'Location adjacent to an inline fragment.',
-                  ],
-                  DirectiveLocationEnum::SCHEMA => [
+                    ],
+                    DirectiveLocationEnum::SCHEMA => [
                     'description' => 'Location adjacent to a schema definition.',
-                  ],
-                  DirectiveLocationEnum::SCALAR => [
+                    ],
+                    DirectiveLocationEnum::SCALAR => [
                     'description' => 'Location adjacent to a scalar definition.',
-                  ],
-                  DirectiveLocationEnum::OBJECT => [
+                    ],
+                    DirectiveLocationEnum::OBJECT => [
                     'description' => 'Location adjacent to an object type definition.',
-                  ],
-                  DirectiveLocationEnum::FIELD_DEFINITION => [
+                    ],
+                    DirectiveLocationEnum::FIELD_DEFINITION => [
                     'description' => 'Location adjacent to a field definition.',
-                  ],
-                  DirectiveLocationEnum::ARGUMENT_DEFINITION => [
+                    ],
+                    DirectiveLocationEnum::ARGUMENT_DEFINITION => [
                     'description' => 'Location adjacent to an argument definition.',
-                  ],
-                  DirectiveLocationEnum::INTERFACE => [
+                    ],
+                    DirectiveLocationEnum::INTERFACE => [
                     'description' => 'Location adjacent to an interface definition.',
-                  ],
-                  DirectiveLocationEnum::UNION => [
+                    ],
+                    DirectiveLocationEnum::UNION => [
                     'description' => 'Location adjacent to a union definition.',
-                  ],
-                  DirectiveLocationEnum::ENUM => [
+                    ],
+                    DirectiveLocationEnum::ENUM => [
                     'description' => 'Location adjacent to an enum definition.',
-                  ],
-                  DirectiveLocationEnum::ENUM_VALUE => [
+                    ],
+                    DirectiveLocationEnum::ENUM_VALUE => [
                     'description' => 'Location adjacent to an enum value definition.',
-                  ],
-                  DirectiveLocationEnum::INPUT_OBJECT => [
+                    ],
+                    DirectiveLocationEnum::INPUT_OBJECT => [
                     'description' => 'Location adjacent to an input object type definition.',
-                  ],
-                  DirectiveLocationEnum::INPUT_FIELD_DEFINITION => [
+                    ],
+                    DirectiveLocationEnum::INPUT_FIELD_DEFINITION => [
                     'description' => 'Location adjacent to an input object field definition.',
-                  ],
+                    ],
                 ],
-              ]);
-          }, true/* $shared */);
+                ]);
+            }, true/* $shared */);
 
         $this->container->add(GraphQL::TYPE_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::TYPE_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::TYPE_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'The fundamental unit of any GraphQL Schema is the type. There are ' .
                 'many kinds of types in GraphQL as represented by the `__TypeKind` enum.' .
                 '\n\nDepending on the kind of a type, certain fields describe ' .
@@ -225,237 +225,237 @@ 
                 'Object and Interface types provide the fields they describe. Abstract ' .
                 'types, Union and Interface, provide the Object types possible ' .
                 'at runtime. List and NonNull types compose other types.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'kind' => [
-                      'type' => newNonNull(__TypeKind()),
-                      'resolve' => function (TypeInterface $type) {
-                          if ($type instanceof ScalarType) {
-                              return TypeKindEnum::SCALAR;
-                          }
-                          if ($type instanceof ObjectType) {
-                              return TypeKindEnum::OBJECT;
-                          }
-                          if ($type instanceof InterfaceType) {
-                              return TypeKindEnum::INTERFACE;
-                          }
-                          if ($type instanceof UnionType) {
-                              return TypeKindEnum::UNION;
-                          }
-                          if ($type instanceof EnumType) {
-                              return TypeKindEnum::ENUM;
-                          }
-                          if ($type instanceof InputObjectType) {
-                              return TypeKindEnum::INPUT_OBJECT;
-                          }
-                          if ($type instanceof ListType) {
-                              return TypeKindEnum::LIST;
-                          }
-                          if ($type instanceof NonNullType) {
-                              return TypeKindEnum::NON_NULL;
-                          }
+                        'type' => newNonNull(__TypeKind()),
+                        'resolve' => function (TypeInterface $type) {
+                            if ($type instanceof ScalarType) {
+                                return TypeKindEnum::SCALAR;
+                            }
+                            if ($type instanceof ObjectType) {
+                                return TypeKindEnum::OBJECT;
+                            }
+                            if ($type instanceof InterfaceType) {
+                                return TypeKindEnum::INTERFACE;
+                            }
+                            if ($type instanceof UnionType) {
+                                return TypeKindEnum::UNION;
+                            }
+                            if ($type instanceof EnumType) {
+                                return TypeKindEnum::ENUM;
+                            }
+                            if ($type instanceof InputObjectType) {
+                                return TypeKindEnum::INPUT_OBJECT;
+                            }
+                            if ($type instanceof ListType) {
+                                return TypeKindEnum::LIST;
+                            }
+                            if ($type instanceof NonNullType) {
+                                return TypeKindEnum::NON_NULL;
+                            }
 
-                          throw new InvalidTypeException(sprintf('Unknown kind of type: %s',
+                            throw new InvalidTypeException(sprintf('Unknown kind of type: %s',
                             $type));
-                      },
+                        },
                     ],
                     'name' => ['type' => String()],
                     'description' => ['type' => String()],
                     'fields' => [
-                      'type' => newList(newNonNull(__Field())),
-                      'args' => [
+                        'type' => newList(newNonNull(__Field())),
+                        'args' => [
                         'includeDeprecated' => [
-                          'type' => Boolean(),
-                          'defaultValue' => false,
+                            'type' => Boolean(),
+                            'defaultValue' => false,
                         ],
-                      ],
-                      'resolve' => function (TypeInterface $type, array $args):
+                        ],
+                        'resolve' => function (TypeInterface $type, array $args):
                       ?array {
-                          ['includeDeprecated' => $includeDeprecated] = $args;
+                            ['includeDeprecated' => $includeDeprecated] = $args;
 
-                          if ($type instanceof ObjectType || $type instanceof InterfaceType) {
-                              $fields = array_values($type->getFields());
+                            if ($type instanceof ObjectType || $type instanceof InterfaceType) {
+                                $fields = array_values($type->getFields());
 
-                              if (!$includeDeprecated) {
-                                  $fields = array_filter($fields,
+                                if (!$includeDeprecated) {
+                                    $fields = array_filter($fields,
                                     function (Field $field) {
                                         return !$field->getIsDeprecated();
                                     });
-                              }
+                                }
 
-                              return $fields;
-                          }
+                                return $fields;
+                            }
 
-                          return null;
-                      },
+                            return null;
+                        },
                     ],
                     'interfaces' => [
-                      'type' => newList(newNonNull(__Type())),
-                      'resolve' => function (TypeInterface $type): ?array {
-                          return $type instanceof ObjectType ? $type->getInterfaces() : null;
-                      },
+                        'type' => newList(newNonNull(__Type())),
+                        'resolve' => function (TypeInterface $type): ?array {
+                            return $type instanceof ObjectType ? $type->getInterfaces() : null;
+                        },
                     ],
                     'possibleTypes' => [
-                      'type' => newList(newNonNull(__Type())),
-                      'resolve' => function (
+                        'type' => newList(newNonNull(__Type())),
+                        'resolve' => function (
                         TypeInterface $type,
                         array $args,
                         array $context,
                         ResolveInfo $info
-                      ):
+                        ):
                       ?array {
-                          /** @var SchemaInterface $schema */
-                          $schema = $info->getSchema();
-                          /** @noinspection PhpParamsInspection */
-                          return $type instanceof AbstractTypeInterface ? $schema->getPossibleTypes($type) : null;
-                      },
+                            /** @var SchemaInterface $schema */
+                            $schema = $info->getSchema();
+                            /** @noinspection PhpParamsInspection */
+                            return $type instanceof AbstractTypeInterface ? $schema->getPossibleTypes($type) : null;
+                        },
                     ],
                     'enumValues' => [
-                      'type' => newList(newNonNull(__EnumValue())),
-                      'args' => [
+                        'type' => newList(newNonNull(__EnumValue())),
+                        'args' => [
                         'includeDeprecated' => [
-                          'type' => Boolean(),
-                          'defaultValue' => false,
+                            'type' => Boolean(),
+                            'defaultValue' => false,
+                        ],
                         ],
-                      ],
-                      'resolve' => function (
+                        'resolve' => function (
                         TypeInterface $type,
                         array $args
-                      ): ?array {
-                          ['includeDeprecated' => $includeDeprecated] = $args;
+                        ): ?array {
+                            ['includeDeprecated' => $includeDeprecated] = $args;
 
-                          if ($type instanceof EnumType) {
-                              $values = array_values($type->getValues());
+                            if ($type instanceof EnumType) {
+                                $values = array_values($type->getValues());
 
-                              if (!$includeDeprecated) {
-                                  $values = array_filter($values,
+                                if (!$includeDeprecated) {
+                                    $values = array_filter($values,
                                     function (Field $field) {
                                         return !$field->getIsDeprecated();
                                     });
-                              }
+                                }
 
-                              return $values;
-                          }
+                                return $values;
+                            }
 
-                          return null;
-                      },
+                            return null;
+                        },
                     ],
                     'inputFields' => [
-                      'type' => newList(newNonNull(__InputValue())),
-                      'resolve' => function (TypeInterface $type): ?array {
-                          return $type instanceof InputObjectType ? $type->getFields() : null;
-                      },
+                        'type' => newList(newNonNull(__InputValue())),
+                        'resolve' => function (TypeInterface $type): ?array {
+                            return $type instanceof InputObjectType ? $type->getFields() : null;
+                        },
                     ],
                     'ofType' => ['type' => __Type()],
-                  ];
-              },
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::FIELD_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::FIELD_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::FIELD_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'Object and Interface types are described by a list of Fields, each of ' .
                 'which has a name, potentially a list of arguments, and a return type.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
                     'args' => [
-                      'type' => newNonNull(newList(newNonNull(__InputValue()))),
-                      'resolve' => function (ArgumentsAwareInterface $directive
-                      ): array {
-                          return $directive->getArguments() ?? [];
-                      },
+                        'type' => newNonNull(newList(newNonNull(__InputValue()))),
+                        'resolve' => function (ArgumentsAwareInterface $directive
+                        ): array {
+                            return $directive->getArguments() ?? [];
+                        },
                     ],
                     'type' => ['type' => newNonNull(__Type())],
                     'isDeprecated' => ['type' => newNonNull(Boolean())],
                     'deprecationReason' => ['type' => String()],
-                  ];
-              },
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::INPUT_VALUE_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::INPUT_VALUE_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'Arguments provided to Fields or Directives and the input fields of an ' .
                 'InputObject are represented as Input Values which describe their type ' .
                 'and optionally a default value.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
                     'type' => ['type' => newNonNull(__Type())],
                     'defaultValue' => [
-                      'type' => String(),
-                      'description' =>
+                        'type' => String(),
+                        'description' =>
                         'A GraphQL-formatted string representing the default value for this ' .
                         'input value.',
-                      'resolve' => function ($inputValue) {
-                          // TODO: Implement this when we have support for printing AST.
-                          return null;
-                      },
+                        'resolve' => function ($inputValue) {
+                            // TODO: Implement this when we have support for printing AST.
+                            return null;
+                        },
                     ],
-                  ];
-              },
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
             return newObjectType([
-              'name' => GraphQL::ENUM_VALUE_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' =>
+                'name' => GraphQL::ENUM_VALUE_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' =>
                 'One possible value for a given Enum. Enum values are unique values, not ' .
                 'a placeholder for a string or numeric value. However an Enum value is ' .
                 'returned in a JSON response as a string.',
-              'fields' => function () {
-                  return [
+                'fields' => function () {
+                    return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
                     'isDeprecated' => ['type' => newNonNull(Boolean())],
                     'deprecationReason' => ['type' => String()],
-                  ];
-              },
+                    ];
+                },
             ]);
         }, true/* $shared */);
 
         $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function () {
             return newEnumType([
-              'name' => GraphQL::TYPE_KIND_INTROSPECTION,
-              'isIntrospection' => true,
-              'description' => 'An enum describing what kind of type a given `__Type` is.',
-              'values' => [
+                'name' => GraphQL::TYPE_KIND_INTROSPECTION,
+                'isIntrospection' => true,
+                'description' => 'An enum describing what kind of type a given `__Type` is.',
+                'values' => [
                 TypeKindEnum::SCALAR => [
-                  'description' => 'Indicates this type is a scalar.',
+                    'description' => 'Indicates this type is a scalar.',
                 ],
                 TypeKindEnum::OBJECT => [
-                  'description' => 'Indicates this type is an object. `fields` and `interfaces` are valid fields.',
+                    'description' => 'Indicates this type is an object. `fields` and `interfaces` are valid fields.',
                 ],
                 TypeKindEnum::INTERFACE => [
-                  'description' => 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.',
+                    'description' => 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.',
                 ],
                 TypeKindEnum::UNION => [
-                  'description' => 'Indicates this type is a union. `possibleTypes` is a valid field.',
+                    'description' => 'Indicates this type is a union. `possibleTypes` is a valid field.',
                 ],
                 TypeKindEnum::ENUM => [
-                  'description' => 'Indicates this type is an enum. `enumValues` is a valid field.',
+                    'description' => 'Indicates this type is an enum. `enumValues` is a valid field.',
                 ],
                 TypeKindEnum::INPUT_OBJECT => [
-                  'description' => 'Indicates this type is an input object. `inputFields` is a valid field.',
+                    'description' => 'Indicates this type is an input object. `inputFields` is a valid field.',
                 ],
                 TypeKindEnum::LIST => [
-                  'description' => 'Indicates this type is a list. `ofType` is a valid field.',
+                    'description' => 'Indicates this type is a list. `ofType` is a valid field.',
                 ],
                 TypeKindEnum::NON_NULL => [
-                  'description' => 'Indicates this type is a non-null. `ofType` is a valid field.',
+                    'description' => 'Indicates this type is a non-null. `ofType` is a valid field.',
+                ],
                 ],
-              ],
             ]);
         }, true/* $shared */);
     }
@@ -466,62 +466,62 @@ 
     protected function registerMetaFields()
     {
         $this->container->add(GraphQL::SCHEMA_META_FIELD_DEFINITION,
-          function ($__Schema) {
-              return new Field([
+            function ($__Schema) {
+                return new Field([
                 'name' => '__schema',
                 'type' => newNonNull($__Schema),
                 'description' => 'Access the current type schema of this server.',
                 'resolve' => function (
-                  $source,
-                  $args,
-                  $context,
-                  ResolveInfo $info
+                    $source,
+                    $args,
+                    $context,
+                    ResolveInfo $info
                 ): SchemaInterface {
                     return $info->getSchema();
                 },
-              ]);
-          })
-          ->withArgument(GraphQL::SCHEMA_INTROSPECTION);
+                ]);
+            })
+            ->withArgument(GraphQL::SCHEMA_INTROSPECTION);
 
         $this->container->add(GraphQL::TYPE_META_FIELD_DEFINITION,
-          function ($__Type) {
-              return new Field([
+            function ($__Type) {
+                return new Field([
                 'name' => '__type',
                 'type' => $__Type,
                 'description' => 'Request the type information of a single type.',
                 'args' => [
-                  'name' => ['type' => newNonNull(String())],
+                    'name' => ['type' => newNonNull(String())],
                 ],
                 'resolve' => function (
-                  $source,
-                  $args,
-                  $context,
-                  ResolveInfo $info
+                    $source,
+                    $args,
+                    $context,
+                    ResolveInfo $info
                 ): TypeInterface {
                     ['name' => $name] = $args;
                     $schema = $info->getSchema();
                     return $schema->getType($name);
                 },
-              ]);
-          })
-          ->withArgument(GraphQL::TYPE_INTROSPECTION);
+                ]);
+            })
+            ->withArgument(GraphQL::TYPE_INTROSPECTION);
 
         $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION,
-          function () {
-              return new Field([
+            function () {
+                return new Field([
                 'name' => '__typename',
                 'type' => newNonNull(String()),
                 'description' => 'The name of the current Object type at runtime.',
                 'resolve' => function (
-                  $source,
-                  $args,
-                  $context,
-                  ResolveInfo $info
+                    $source,
+                    $args,
+                    $context,
+                    ResolveInfo $info
                 ): string {
                     $parentType = $info->getParentType();
                     return null !== $parentType ? $parentType->getName() : null;
                 },
-              ]);
-          });
+                ]);
+            });
     }
 }

Spacing +36 added lines, -36 removed lines

@@ -58,7 +58,7 @@ 
      */
     protected function registerIntrospectionTypes()
     {
-        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function () {
+        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::SCHEMA_INTROSPECTION,
               'isIntrospection' => true,
@@ -66,19 +66,19 @@ 
                 'A GraphQL Schema defines the capabilities of a GraphQL server. It ' .
                 'exposes all available types and directives on the server, as well as ' .
                 'the entry points for query, mutation, and subscription operations.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'types' => [
                       'description' => 'A list of all types supported by this server.',
                       'type' => newNonNull(newList(newNonNull(__Type()))),
-                      'resolve' => function (SchemaInterface $schema): array {
+                      'resolve' => function(SchemaInterface $schema): array {
                           return array_values($schema->getTypeMap());
                       },
                     ],
                     'queryType' => [
                       'description' => 'The type that query operations will be rooted at.',
                       'type' => newNonNull(__Type()),
-                      'resolve' => function (SchemaInterface $schema
+                      'resolve' => function(SchemaInterface $schema
                       ): ?TypeInterface {
                           return $schema->getQueryType();
                       },
@@ -88,7 +88,7 @@ 
                         'If this server supports mutation, the type that ' .
                         'mutation operations will be rooted at.',
                       'type' => __Type(),
-                      'resolve' => function (SchemaInterface $schema
+                      'resolve' => function(SchemaInterface $schema
                       ): ?TypeInterface {
                           return $schema->getMutationType();
                       },
@@ -98,7 +98,7 @@ 
                         'If this server support subscription, the type that ' .
                         'subscription operations will be rooted at.',
                       'type' => __Type(),
-                      'resolve' => function (SchemaInterface $schema
+                      'resolve' => function(SchemaInterface $schema
                       ): ?TypeInterface {
                           return $schema->getSubscriptionType();
                       },
@@ -106,7 +106,7 @@ 
                     'directives' => [
                       'description' => 'A list of all directives supported by this server.',
                       'type' => newNonNull(newList(newNonNull(__Directive()))),
-                      'resolve' => function (SchemaInterface $schema): array {
+                      'resolve' => function(SchemaInterface $schema): array {
                           return $schema->getDirectives();
                       },
                     ],
@@ -115,7 +115,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::DIRECTIVE_INTROSPECTION,
               'isIntrospection' => true,
@@ -126,7 +126,7 @@ 
                 'execution behavior in ways field arguments will not suffice, such as ' .
                 'conditionally including or skipping a field. Directives provide this by ' .
                 'describing additional information to the executor.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
@@ -135,7 +135,7 @@ 
                     ],
                     'args' => [
                       'type' => newNonNull(newList(newNonNull(__InputValue()))),
-                      'resolve' => function (DirectiveInterface $directive
+                      'resolve' => function(DirectiveInterface $directive
                       ): array {
                           return $directive->getArguments() ?: [];
                       },
@@ -146,7 +146,7 @@ 
         }, true/* $shared */);
 
         $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
-          function () {
+          function() {
               return newEnumType([
                 'name' => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                 'isIntrospection' => true,
@@ -212,7 +212,7 @@ 
               ]);
           }, true/* $shared */);
 
-        $this->container->add(GraphQL::TYPE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::TYPE_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::TYPE_INTROSPECTION,
               'isIntrospection' => true,
@@ -225,11 +225,11 @@ 
                 'Object and Interface types provide the fields they describe. Abstract ' .
                 'types, Union and Interface, provide the Object types possible ' .
                 'at runtime. List and NonNull types compose other types.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'kind' => [
                       'type' => newNonNull(__TypeKind()),
-                      'resolve' => function (TypeInterface $type) {
+                      'resolve' => function(TypeInterface $type) {
                           if ($type instanceof ScalarType) {
                               return TypeKindEnum::SCALAR;
                           }
@@ -269,7 +269,7 @@ 
                           'defaultValue' => false,
                         ],
                       ],
-                      'resolve' => function (TypeInterface $type, array $args):
+                      'resolve' => function(TypeInterface $type, array $args):
                       ?array {
                           ['includeDeprecated' => $includeDeprecated] = $args;
 
@@ -278,7 +278,7 @@ 
 
                               if (!$includeDeprecated) {
                                   $fields = array_filter($fields,
-                                    function (Field $field) {
+                                    function(Field $field) {
                                         return !$field->getIsDeprecated();
                                     });
                               }
@@ -291,13 +291,13 @@ 
                     ],
                     'interfaces' => [
                       'type' => newList(newNonNull(__Type())),
-                      'resolve' => function (TypeInterface $type): ?array {
+                      'resolve' => function(TypeInterface $type): ?array {
                           return $type instanceof ObjectType ? $type->getInterfaces() : null;
                       },
                     ],
                     'possibleTypes' => [
                       'type' => newList(newNonNull(__Type())),
-                      'resolve' => function (
+                      'resolve' => function(
                         TypeInterface $type,
                         array $args,
                         array $context,
@@ -318,7 +318,7 @@ 
                           'defaultValue' => false,
                         ],
                       ],
-                      'resolve' => function (
+                      'resolve' => function(
                         TypeInterface $type,
                         array $args
                       ): ?array {
@@ -329,7 +329,7 @@ 
 
                               if (!$includeDeprecated) {
                                   $values = array_filter($values,
-                                    function (Field $field) {
+                                    function(Field $field) {
                                         return !$field->getIsDeprecated();
                                     });
                               }
@@ -342,7 +342,7 @@ 
                     ],
                     'inputFields' => [
                       'type' => newList(newNonNull(__InputValue())),
-                      'resolve' => function (TypeInterface $type): ?array {
+                      'resolve' => function(TypeInterface $type): ?array {
                           return $type instanceof InputObjectType ? $type->getFields() : null;
                       },
                     ],
@@ -352,20 +352,20 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::FIELD_INTROSPECTION, function () {
+        $this->container->add(GraphQL::FIELD_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::FIELD_INTROSPECTION,
               'isIntrospection' => true,
               'description' =>
                 'Object and Interface types are described by a list of Fields, each of ' .
                 'which has a name, potentially a list of arguments, and a return type.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
                     'args' => [
                       'type' => newNonNull(newList(newNonNull(__InputValue()))),
-                      'resolve' => function (ArgumentsAwareInterface $directive
+                      'resolve' => function(ArgumentsAwareInterface $directive
                       ): array {
                           return $directive->getArguments() ?? [];
                       },
@@ -378,7 +378,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::INPUT_VALUE_INTROSPECTION,
               'isIntrospection' => true,
@@ -386,7 +386,7 @@ 
                 'Arguments provided to Fields or Directives and the input fields of an ' .
                 'InputObject are represented as Input Values which describe their type ' .
                 'and optionally a default value.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
@@ -396,7 +396,7 @@ 
                       'description' =>
                         'A GraphQL-formatted string representing the default value for this ' .
                         'input value.',
-                      'resolve' => function ($inputValue) {
+                      'resolve' => function($inputValue) {
                           // TODO: Implement this when we have support for printing AST.
                           return null;
                       },
@@ -406,7 +406,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
+        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
             return newObjectType([
               'name' => GraphQL::ENUM_VALUE_INTROSPECTION,
               'isIntrospection' => true,
@@ -414,7 +414,7 @@ 
                 'One possible value for a given Enum. Enum values are unique values, not ' .
                 'a placeholder for a string or numeric value. However an Enum value is ' .
                 'returned in a JSON response as a string.',
-              'fields' => function () {
+              'fields' => function() {
                   return [
                     'name' => ['type' => newNonNull(String())],
                     'description' => ['type' => String()],
@@ -425,7 +425,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function () {
+        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function() {
             return newEnumType([
               'name' => GraphQL::TYPE_KIND_INTROSPECTION,
               'isIntrospection' => true,
@@ -466,12 +466,12 @@ 
     protected function registerMetaFields()
     {
         $this->container->add(GraphQL::SCHEMA_META_FIELD_DEFINITION,
-          function ($__Schema) {
+          function($__Schema) {
               return new Field([
                 'name' => '__schema',
                 'type' => newNonNull($__Schema),
                 'description' => 'Access the current type schema of this server.',
-                'resolve' => function (
+                'resolve' => function(
                   $source,
                   $args,
                   $context,
@@ -484,7 +484,7 @@ 
           ->withArgument(GraphQL::SCHEMA_INTROSPECTION);
 
         $this->container->add(GraphQL::TYPE_META_FIELD_DEFINITION,
-          function ($__Type) {
+          function($__Type) {
               return new Field([
                 'name' => '__type',
                 'type' => $__Type,
@@ -492,7 +492,7 @@ 
                 'args' => [
                   'name' => ['type' => newNonNull(String())],
                 ],
-                'resolve' => function (
+                'resolve' => function(
                   $source,
                   $args,
                   $context,
@@ -507,12 +507,12 @@ 
           ->withArgument(GraphQL::TYPE_INTROSPECTION);
 
         $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION,
-          function () {
+          function() {
               return new Field([
                 'name' => '__typename',
                 'type' => newNonNull(String()),
                 'description' => 'The name of the current Object type at runtime.',
-                'resolve' => function (
+                'resolve' => function(
                   $source,
                   $args,
                   $context,

src/Type/definition.php

Indentation +34 added lines, -34 removed lines

@@ -59,8 +59,8 @@ 
 function assertType($type)
 {
     invariant(
-      $type instanceof TypeInterface,
-      \sprintf('Expected %s to be a GraphQL type.', (string)$type)
+        $type instanceof TypeInterface,
+        \sprintf('Expected %s to be a GraphQL type.', (string)$type)
     );
 }
 
@@ -72,8 +72,8 @@ 
 function assertScalarType(TypeInterface $type)
 {
     invariant(
-      $type instanceof ScalarType,
-      \sprintf('Expected %s to be a GraphQL Scalar type.', (string)$type)
+        $type instanceof ScalarType,
+        \sprintf('Expected %s to be a GraphQL Scalar type.', (string)$type)
     );
 }
 
@@ -85,8 +85,8 @@ 
 function assertObjectType(TypeInterface $type)
 {
     invariant(
-      $type instanceof ObjectType,
-      \sprintf('Expected %s to be a GraphQL Object type.', (string)$type)
+        $type instanceof ObjectType,
+        \sprintf('Expected %s to be a GraphQL Object type.', (string)$type)
     );
 }
 
@@ -98,8 +98,8 @@ 
 function assertInterfaceType(TypeInterface $type)
 {
     invariant(
-      $type instanceof InterfaceType,
-      \sprintf('Expected %s to be a GraphQL Interface type.', (string)$type)
+        $type instanceof InterfaceType,
+        \sprintf('Expected %s to be a GraphQL Interface type.', (string)$type)
     );
 }
 
@@ -111,8 +111,8 @@ 
 function assertUnionType(TypeInterface $type)
 {
     invariant(
-      $type instanceof UnionType,
-      \sprintf('Expected %s to be a GraphQL Union type.', (string)$type)
+        $type instanceof UnionType,
+        \sprintf('Expected %s to be a GraphQL Union type.', (string)$type)
     );
 }
 
@@ -124,8 +124,8 @@ 
 function assertEnumType(TypeInterface $type)
 {
     invariant(
-      $type instanceof EnumType,
-      \sprintf('Expected %s to be a GraphQL Enum type.', (string)$type)
+        $type instanceof EnumType,
+        \sprintf('Expected %s to be a GraphQL Enum type.', (string)$type)
     );
 }
 
@@ -137,8 +137,8 @@ 
 function assertInputObjectType(TypeInterface $type)
 {
     invariant(
-      $type instanceof InputObjectType,
-      \sprintf('Expected %s to be a GraphQL InputObject type.', (string)$type)
+        $type instanceof InputObjectType,
+        \sprintf('Expected %s to be a GraphQL InputObject type.', (string)$type)
     );
 }
 
@@ -150,8 +150,8 @@ 
 function assertListType(TypeInterface $type)
 {
     invariant(
-      $type instanceof ListType,
-      \sprintf('Expected %s to be a GraphQL List type.', (string)$type)
+        $type instanceof ListType,
+        \sprintf('Expected %s to be a GraphQL List type.', (string)$type)
     );
 }
 
@@ -163,8 +163,8 @@ 
 function assertNonNullType(TypeInterface $type)
 {
     invariant(
-      $type instanceof NonNullType,
-      \sprintf('Expected %s to be a GraphQL NonNull type.', (string)$type)
+        $type instanceof NonNullType,
+        \sprintf('Expected %s to be a GraphQL NonNull type.', (string)$type)
     );
 }
 
@@ -190,8 +190,8 @@ 
 function assertInputType(TypeInterface $type)
 {
     invariant(
-      isInputType($type),
-      \sprintf('Expected %s to be a GraphQL input type.', (string)$type)
+        isInputType($type),
+        \sprintf('Expected %s to be a GraphQL input type.', (string)$type)
     );
 }
 
@@ -217,8 +217,8 @@ 
 function assertOutputType(TypeInterface $type)
 {
     invariant(
-      isOutputType($type),
-      \sprintf('Expected %s to be a GraphQL output type.', (string)$type)
+        isOutputType($type),
+        \sprintf('Expected %s to be a GraphQL output type.', (string)$type)
     );
 }
 
@@ -230,8 +230,8 @@ 
 function assertLeafType(TypeInterface $type)
 {
     invariant(
-      $type instanceof LeafTypeInterface,
-      \sprintf('Expected %s to be a GraphQL leaf type.', (string)$type)
+        $type instanceof LeafTypeInterface,
+        \sprintf('Expected %s to be a GraphQL leaf type.', (string)$type)
     );
 }
 
@@ -243,8 +243,8 @@ 
 function assertCompositeType(TypeInterface $type)
 {
     invariant(
-      $type instanceof CompositeTypeInterface,
-      \sprintf('Expected %s to be a GraphQL composite type.', (string)$type)
+        $type instanceof CompositeTypeInterface,
+        \sprintf('Expected %s to be a GraphQL composite type.', (string)$type)
     );
 }
 
@@ -256,8 +256,8 @@ 
 function assertAbstractType(TypeInterface $type)
 {
     invariant(
-      $type instanceof AbstractTypeInterface,
-      \sprintf('Expected %s to be a GraphQL abstract type.', (string)$type)
+        $type instanceof AbstractTypeInterface,
+        \sprintf('Expected %s to be a GraphQL abstract type.', (string)$type)
     );
 }
 
@@ -269,8 +269,8 @@ 
 function assertWrappingType(TypeInterface $type)
 {
     invariant(
-      $type instanceof WrappingTypeInterface,
-      \sprintf('Expected %s to be a GraphQL wrapping type.', (string)$type)
+        $type instanceof WrappingTypeInterface,
+        \sprintf('Expected %s to be a GraphQL wrapping type.', (string)$type)
     );
 }
 
@@ -293,8 +293,8 @@ 
 function assertNullableType(TypeInterface $type): TypeInterface
 {
     invariant(
-      isNullableType($type),
-      \sprintf('Expected %s to be a GraphQL nullable type.', (string)$type)
+        isNullableType($type),
+        \sprintf('Expected %s to be a GraphQL nullable type.', (string)$type)
     );
 
     return $type;
@@ -322,8 +322,8 @@ 
 function assertNamedType(TypeInterface $type)
 {
     invariant(
-      $type instanceof NamedTypeInterface,
-      \sprintf('Expected %s to be a GraphQL named type.', (string)$type)
+        $type instanceof NamedTypeInterface,
+        \sprintf('Expected %s to be a GraphQL named type.', (string)$type)
     );
 }
 

src/Type/directives.php

Indentation +7 added lines, -7 removed lines

@@ -37,9 +37,9 @@ 
 function specifiedDirectives(): array
 {
     return [
-      IncludeDirective(),
-      SkipDirective(),
-      DeprecatedDirective(),
+        IncludeDirective(),
+        SkipDirective(),
+        DeprecatedDirective(),
     ];
 }
 
@@ -51,9 +51,9 @@ 
 function isSpecifiedDirective(DirectiveInterface $directive): bool
 {
     return arraySome(
-      specifiedDirectives(),
-      function (DirectiveInterface $specifiedDirective) use ($directive) {
-          return $specifiedDirective->getName() === $directive->getName();
-      }
+        specifiedDirectives(),
+        function (DirectiveInterface $specifiedDirective) use ($directive) {
+            return $specifiedDirective->getName() === $directive->getName();
+        }
     );
 }

Spacing +1 added lines, -1 removed lines

@@ -52,7 +52,7 @@
 {
     return arraySome(
       specifiedDirectives(),
-      function (DirectiveInterface $specifiedDirective) use ($directive) {
+      function(DirectiveInterface $specifiedDirective) use ($directive) {
           return $specifiedDirective->getName() === $directive->getName();
       }
     );