digiaonline / graphql-php

src/Execution/ExecutionStrategy.php

Spacing +5 added lines, -5 removed lines

@@ -251,7 +251,7 @@ 
         if ($isContainsPromise) {
             $keys    = array_keys($finalResults);
             $promise = \React\Promise\all(array_values($finalResults));
-            $promise->then(function ($values) use ($keys, &$finalResults) {
+            $promise->then(function($values) use ($keys, &$finalResults) {
                 foreach ($values as $i => $value) {
                     $finalResults[$keys[$i]] = $value;
                 }
@@ -475,7 +475,7 @@ 
             if ($this->isPromise($completed)) {
                 $context = $this->context;
                 /** @var ExtendedPromiseInterface $completed */
-                return $completed->then(null, function ($error) use ($context) {
+                return $completed->then(null, function($error) use ($context) {
                     $context->addError($error);
                     return new \React\Promise\FulfilledPromise(null);
                 });
@@ -541,7 +541,7 @@ 
     ) {
         if ($this->isPromise($result)) {
             /** @var ExtendedPromiseInterface $result */
-            return $result->then(function (&$value) use ($returnType, $fieldNodes, $info, $path) {
+            return $result->then(function(&$value) use ($returnType, $fieldNodes, $info, $path) {
                 return $this->completeValue($returnType, $fieldNodes, $info, $path, $value);
             });
         }
@@ -629,7 +629,7 @@ 
 
         if ($this->isPromise($runtimeType)) {
             /** @var ExtendedPromiseInterface $runtimeType */
-            return $runtimeType->then(function ($resolvedRuntimeType) use (
+            return $runtimeType->then(function($resolvedRuntimeType) use (
                 $returnType,
                 $fieldNodes,
                 $info,
@@ -744,7 +744,7 @@ 
 
         if (!empty($promisedIsTypeOfResults)) {
             return \React\Promise\all($promisedIsTypeOfResults)
-                ->then(function ($isTypeOfResults) use ($possibleTypes) {
+                ->then(function($isTypeOfResults) use ($possibleTypes) {
                     foreach ($isTypeOfResults as $index => $result) {
                         if ($result) {
                             return $possibleTypes[$index];

src/SchemaBuilder/DefinitionBuilder.php

Spacing +17 added lines, -17 removed lines

@@ -97,7 +97,7 @@ 
 
         $builtInTypes = keyMap(
             \array_merge(specifiedScalarTypes(), introspectionTypes()),
-            function (NamedTypeInterface $type) {
+            function(NamedTypeInterface $type) {
                 return $type->getName();
             }
         );
@@ -159,7 +159,7 @@ 
         return GraphQLDirective([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'locations'   => \array_map(function (NameNode $node) {
+            'locations'   => \array_map(function(NameNode $node) {
                 return $node->getValue();
             }, $node->getLocations()),
             'args'        => $node->hasArguments() ? $this->buildArguments($node->getArguments()) : [],
@@ -208,10 +208,10 @@ 
     {
         return keyValueMap(
             $nodes,
-            function (InputValueDefinitionNode $value) {
+            function(InputValueDefinitionNode $value) {
                 return $value->getNameValue();
             },
-            function (InputValueDefinitionNode $value): array {
+            function(InputValueDefinitionNode $value): array {
                 $type         = $this->buildWrappedType($value->getType());
                 $defaultValue = $value->getDefaultValue();
                 return [
@@ -263,11 +263,11 @@ 
         return GraphQLObjectType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => function () use ($node) {
+            'fields'      => function() use ($node) {
                 return $this->buildFields($node);
             },
-            'interfaces'  => function () use ($node) {
-                return $node->hasInterfaces() ? \array_map(function (NodeInterface $interface) {
+            'interfaces'  => function() use ($node) {
+                return $node->hasInterfaces() ? \array_map(function(NodeInterface $interface) {
                     return $this->buildType($interface);
                 }, $node->getInterfaces()) : [];
             },
@@ -284,11 +284,11 @@ 
 
         return $node->hasFields() ? keyValueMap(
             $node->getFields(),
-            function ($value) {
+            function($value) {
                 /** @noinspection PhpUndefinedMethodInspection */
                 return $value->getNameValue();
             },
-            function ($value) use ($resolverMap) {
+            function($value) use ($resolverMap) {
                 return $this->buildField($value, $resolverMap);
             }
         ) : [];
@@ -303,7 +303,7 @@ 
         return GraphQLInterfaceType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => function () use ($node): array {
+            'fields'      => function() use ($node): array {
                 return $this->buildFields($node);
             },
             'astNode'     => $node,
@@ -321,10 +321,10 @@ 
             'description' => $node->getDescriptionValue(),
             'values'      => $node->hasValues() ? keyValueMap(
                 $node->getValues(),
-                function (EnumValueDefinitionNode $value): string {
+                function(EnumValueDefinitionNode $value): string {
                     return $value->getNameValue();
                 },
-                function (EnumValueDefinitionNode $value): array {
+                function(EnumValueDefinitionNode $value): array {
                     return [
                         'description'       => $value->getDescriptionValue(),
                         'deprecationReason' => $this->getDeprecationReason($value),
@@ -345,7 +345,7 @@ 
         return GraphQLUnionType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'types'       => $node->hasTypes() ? \array_map(function (TypeNodeInterface $type) {
+            'types'       => $node->hasTypes() ? \array_map(function(TypeNodeInterface $type) {
                 return $this->buildType($type);
             }, $node->getTypes()) : [],
             'astNode'     => $node,
@@ -361,7 +361,7 @@ 
         return GraphQLScalarType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'serialize'   => function ($value) {
+            'serialize'   => function($value) {
                 return $value;
             },
             'astNode'     => $node,
@@ -377,13 +377,13 @@ 
         return GraphQLInputObjectType([
             'name'        => $node->getNameValue(),
             'description' => $node->getDescriptionValue(),
-            'fields'      => $node->hasFields() ? function () use ($node) {
+            'fields'      => $node->hasFields() ? function() use ($node) {
                 return keyValueMap(
                     $node->getFields(),
-                    function (InputValueDefinitionNode $value): string {
+                    function(InputValueDefinitionNode $value): string {
                         return $value->getNameValue();
                     },
-                    function (InputValueDefinitionNode $value): array {
+                    function(InputValueDefinitionNode $value): array {
                         $type = $this->buildWrappedType($value->getType());
                         return [
                             'type'         => $type,

src/Type/Schema.php

Spacing +4 added lines, -4 removed lines

@@ -126,7 +126,7 @@ 
      */
     public function getDirective(string $name): ?Directive
     {
-        return find($this->directives, function (Directive $directive) use ($name) {
+        return find($this->directives, function(Directive $directive) use ($name) {
             return $directive->getName() === $name;
         });
     }
@@ -179,7 +179,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;
@@ -384,7 +384,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());
 
@@ -418,7 +418,7 @@ 
             return $map;
         }
 
-        return \array_reduce($directive->getArguments(), function ($map, Argument $argument) {
+        return \array_reduce($directive->getArguments(), function($map, Argument $argument) {
             return $this->typeMapReducer($map, $argument->getType());
         }, $map);
     }

src/Type/ScalarTypesProvider.php

Spacing +20 added lines, -20 removed lines

@@ -33,17 +33,17 @@ 
      */
     public function register()
     {
-        $this->container->add(GraphQL::BOOLEAN, function (BooleanCoercer $coercer) {
+        $this->container->add(GraphQL::BOOLEAN, function(BooleanCoercer $coercer) {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::BOOLEAN,
                 'description'  => 'The `Boolean` scalar type represents `true` or `false`.',
-                'serialize'    => function ($value) use ($coercer) {
+                'serialize'    => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseValue'   => function ($value) use ($coercer) {
+                'parseValue'   => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseLiteral' => function (NodeInterface $node) {
+                'parseLiteral' => function(NodeInterface $node) {
                     if ($node instanceof BooleanValueNode) {
                         return $node->getValue();
                     }
@@ -53,20 +53,20 @@ 
         }, true/* $shared */)
             ->withArgument(BooleanCoercer::class);
 
-        $this->container->add(GraphQL::FLOAT, function (FloatCoercer $coercer) {
+        $this->container->add(GraphQL::FLOAT, function(FloatCoercer $coercer) {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::FLOAT,
                 'description'  =>
                     'The `Float` scalar type represents signed double-precision fractional ' .
                     'values as specified by ' .
                     '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point).',
-                'serialize'    => function ($value) use ($coercer) {
+                'serialize'    => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseValue'   => function ($value) use ($coercer) {
+                'parseValue'   => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseLiteral' => function (NodeInterface $node) {
+                'parseLiteral' => function(NodeInterface $node) {
                     if ($node instanceof FloatValueNode || $node instanceof IntValueNode) {
                         return $node->getValue();
                     }
@@ -76,19 +76,19 @@ 
         }, true/* $shared */)
             ->withArgument(FloatCoercer::class);
 
-        $this->container->add(GraphQL::INT, function (IntCoercer $coercer) {
+        $this->container->add(GraphQL::INT, function(IntCoercer $coercer) {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::INT,
                 'description'  =>
                     'The `Int` scalar type represents non-fractional signed whole numeric ' .
                     'values. Int can represent values between -(2^31) and 2^31 - 1.',
-                'serialize'    => function ($value) use ($coercer) {
+                'serialize'    => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseValue'   => function ($value) use ($coercer) {
+                'parseValue'   => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseLiteral' => function (NodeInterface $node) {
+                'parseLiteral' => function(NodeInterface $node) {
                     if ($node instanceof IntValueNode) {
                         $value = (int)$node->getValue();
                         if ((string)$node->getValue() === (string)$value &&
@@ -102,7 +102,7 @@ 
         }, true/* $shared */)
             ->withArgument(IntCoercer::class);
 
-        $this->container->add(GraphQL::ID, function (StringCoercer $coercer) {
+        $this->container->add(GraphQL::ID, function(StringCoercer $coercer) {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::ID,
                 'description'  =>
@@ -111,13 +111,13 @@ 
                     'response as a String; however, it is not intended to be human-readable. ' .
                     'When expected as an input type, any string (such as `"4"`) or integer ' .
                     '(such as `4`) input value will be accepted as an ID.',
-                'serialize'    => function ($value) use ($coercer) {
+                'serialize'    => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseValue'   => function ($value) use ($coercer) {
+                'parseValue'   => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseLiteral' => function (NodeInterface $node) {
+                'parseLiteral' => function(NodeInterface $node) {
                     if ($node instanceof StringValueNode || $node instanceof IntValueNode) {
                         return $node->getValue();
                     }
@@ -127,20 +127,20 @@ 
         }, true/* $shared */)
             ->withArgument(StringCoercer::class);
 
-        $this->container->add(GraphQL::STRING, function (StringCoercer $coercer) {
+        $this->container->add(GraphQL::STRING, function(StringCoercer $coercer) {
             return GraphQLScalarType([
                 'name'         => TypeNameEnum::STRING,
                 'description'  =>
                     'The `String` scalar type represents textual data, represented as UTF-8 ' .
                     'character sequences. The String type is most often used by GraphQL to ' .
                     'represent free-form human-readable text.',
-                'serialize'    => function ($value) use ($coercer) {
+                'serialize'    => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseValue'   => function ($value) use ($coercer) {
+                'parseValue'   => function($value) use ($coercer) {
                     return $coercer->coerce($value);
                 },
-                'parseLiteral' => function (NodeInterface $node) {
+                'parseLiteral' => function(NodeInterface $node) {
                     if ($node instanceof StringValueNode) {
                         return $node->getValue();
                     }

src/Execution/ExecutionResult.php

Spacing +1 added lines, -1 removed lines

@@ -66,7 +66,7 @@
         $array = ['data' => $this->data];
 
         if (!empty($this->errors)) {
-            $array['errors'] = array_map(function (GraphQLException $error) {
+            $array['errors'] = array_map(function(GraphQLException $error) {
                 return $error->toArray();
             }, $this->errors);
         }

src/Type/IntrospectionTypesProvider.php

Spacing +30 added lines, -30 removed lines

@@ -42,7 +42,7 @@ 
      */
     public function register()
     {
-        $this->container->add(GraphQL::INTROSPECTION_SCHEMA, function () {
+        $this->container->add(GraphQL::INTROSPECTION_SCHEMA, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_SCHEMA,
                 'isIntrospection' => true,
@@ -50,19 +50,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'        => GraphQLNonNull(GraphQLList(GraphQLNonNull(__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'        => GraphQLNonNull(__Type()),
-                            'resolve'     => function (SchemaInterface $schema): ?TypeInterface {
+                            'resolve'     => function(SchemaInterface $schema): ?TypeInterface {
                                 return $schema->getQueryType();
                             },
                         ],
@@ -71,7 +71,7 @@ 
                                 'If this server supports mutation, the type that ' .
                                 'mutation operations will be rooted at.',
                             'type'        => __Type(),
-                            'resolve'     => function (SchemaInterface $schema): ?TypeInterface {
+                            'resolve'     => function(SchemaInterface $schema): ?TypeInterface {
                                 return $schema->getMutationType();
                             },
                         ],
@@ -80,14 +80,14 @@ 
                                 'If this server support subscription, the type that ' .
                                 'subscription operations will be rooted at.',
                             'type'        => __Type(),
-                            'resolve'     => function (SchemaInterface $schema): ?TypeInterface {
+                            'resolve'     => function(SchemaInterface $schema): ?TypeInterface {
                                 return $schema->getSubscriptionType();
                             },
                         ],
                         'directives'       => [
                             'description' => 'A list of all directives supported by this server.',
                             'type'        => GraphQLNonNull(GraphQLList(GraphQLNonNull(__Directive()))),
-                            'resolve'     => function (SchemaInterface $schema): array {
+                            'resolve'     => function(SchemaInterface $schema): array {
                                 return $schema->getDirectives();
                             },
                         ],
@@ -96,7 +96,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_DIRECTIVE, function () {
+        $this->container->add(GraphQL::INTROSPECTION_DIRECTIVE, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_DIRECTIVE,
                 'isIntrospection' => true,
@@ -107,7 +107,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' => GraphQLNonNull(GraphQLString())],
                         'description' => ['type' => GraphQLString()],
@@ -116,7 +116,7 @@ 
                         ],
                         'args'        => [
                             'type'    => GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue()))),
-                            'resolve' => function (DirectiveInterface $directive): array {
+                            'resolve' => function(DirectiveInterface $directive): array {
                                 return $directive->getArguments() ?: [];
                             },
                         ],
@@ -125,7 +125,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_DIRECTIVE_LOCATION, function () {
+        $this->container->add(GraphQL::INTROSPECTION_DIRECTIVE_LOCATION, function() {
             return GraphQLEnumType([
                 'name'            => GraphQL::INTROSPECTION_DIRECTIVE_LOCATION,
                 'isIntrospection' => true,
@@ -191,7 +191,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_TYPE, function () {
+        $this->container->add(GraphQL::INTROSPECTION_TYPE, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_TYPE,
                 'isIntrospection' => true,
@@ -204,11 +204,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'    => GraphQLNonNull(__TypeKind()),
-                            'resolve' => function (TypeInterface $type) {
+                            'resolve' => function(TypeInterface $type) {
                                 if ($type instanceof ScalarType) {
                                     return TypeKindEnum::SCALAR;
                                 }
@@ -244,7 +244,7 @@ 
                             'args'    => [
                                 'includeDeprecated' => ['type' => GraphQLBoolean(), 'defaultValue' => false],
                             ],
-                            'resolve' => function (TypeInterface $type, array $args):
+                            'resolve' => function(TypeInterface $type, array $args):
                             ?array {
                                 $includeDeprecated = $args[0] ?? null;
 
@@ -252,7 +252,7 @@ 
                                     $fields = array_values($type->getFields());
 
                                     if (!$includeDeprecated) {
-                                        $fields = array_filter($fields, function (Field $field) {
+                                        $fields = array_filter($fields, function(Field $field) {
                                             return !$field->getIsDeprecated();
                                         });
                                     }
@@ -265,13 +265,13 @@ 
                         ],
                         'interfaces'    => [
                             'type'    => GraphQLList(GraphQLNonNull(__Type())),
-                            'resolve' => function (TypeInterface $type): ?array {
+                            'resolve' => function(TypeInterface $type): ?array {
                                 return $type instanceof ObjectType ? $type->getInterfaces() : null;
                             },
                         ],
                         'possibleTypes' => [
                             'type'    => GraphQLList(GraphQLNonNull(__Type())),
-                            'resolve' => function (TypeInterface $type, array $args, array $context, ResolveInfo
+                            'resolve' => function(TypeInterface $type, array $args, array $context, ResolveInfo
                             $info):
                             ?array {
                                 /** @var SchemaInterface $schema */
@@ -285,14 +285,14 @@ 
                             'args'    => [
                                 'includeDeprecated' => ['type' => GraphQLBoolean(), 'defaultValue' => false],
                             ],
-                            'resolve' => function (TypeInterface $type, array $args): ?array {
+                            'resolve' => function(TypeInterface $type, array $args): ?array {
                                 [$includeDeprecated] = $args;
 
                                 if ($type instanceof EnumType) {
                                     $values = array_values($type->getValues());
 
                                     if (!$includeDeprecated) {
-                                        $values = array_filter($values, function (Field $field) {
+                                        $values = array_filter($values, function(Field $field) {
                                             return !$field->getIsDeprecated();
                                         });
                                     }
@@ -305,7 +305,7 @@ 
                         ],
                         'inputFields'   => [
                             'type'    => GraphQLList(GraphQLNonNull(__InputValue())),
-                            'resolve' => function (TypeInterface $type): ?array {
+                            'resolve' => function(TypeInterface $type): ?array {
                                 return $type instanceof InputObjectType ? $type->getFields() : null;
                             },
                         ],
@@ -315,20 +315,20 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_FIELD, function () {
+        $this->container->add(GraphQL::INTROSPECTION_FIELD, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_FIELD,
                 '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' => GraphQLNonNull(GraphQLString())],
                         'description'       => ['type' => GraphQLString()],
                         'args'              => [
                             'type'    => GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue()))),
-                            'resolve' => function (ArgumentsAwareInterface $directive): array {
+                            'resolve' => function(ArgumentsAwareInterface $directive): array {
                                 return $directive->getArguments() ?? [];
                             },
                         ],
@@ -340,7 +340,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_INPUT_VALUE, function () {
+        $this->container->add(GraphQL::INTROSPECTION_INPUT_VALUE, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_INPUT_VALUE,
                 'isIntrospection' => true,
@@ -348,7 +348,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' => GraphQLNonNull(GraphQLString())],
                         'description'  => ['type' => GraphQLString()],
@@ -358,7 +358,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;
                             }
@@ -368,7 +368,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_ENUM_VALUE, function () {
+        $this->container->add(GraphQL::INTROSPECTION_ENUM_VALUE, function() {
             return GraphQLObjectType([
                 'name'            => GraphQL::INTROSPECTION_ENUM_VALUE,
                 'isIntrospection' => true,
@@ -376,7 +376,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' => GraphQLNonNull(GraphQLString())],
                         'description'       => ['type' => GraphQLString()],
@@ -387,7 +387,7 @@ 
             ]);
         }, true/* $shared */);
 
-        $this->container->add(GraphQL::INTROSPECTION_TYPE_KIND, function () {
+        $this->container->add(GraphQL::INTROSPECTION_TYPE_KIND, function() {
             return GraphQLEnumType([
                 'name'            => GraphQL::INTROSPECTION_TYPE_KIND,
                 'isIntrospection' => true,