digiaonline / graphql-php

src/Type/IntrospectionProvider.php

Spacing +36 added lines, -36 removed lines

@@ -58,7 +58,7 @@ 
     protected function registerIntrospectionTypes()
     {
         $this->container
-            ->share(GraphQL::SCHEMA_INTROSPECTION, function () {
+            ->share(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 (Schema $schema): array {
+                                'resolve'     => function(Schema $schema): array {
                                     return \array_values($schema->getTypeMap());
                                 },
                             ],
                             'queryType'        => [
                                 'description' => 'The type that query operations will be rooted at.',
                                 'type'        => newNonNull(__Type()),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getQueryType();
                                 },
                             ],
@@ -87,7 +87,7 @@ 
                                     'If this server supports mutation, the type that ' .
                                     'mutation operations will be rooted at.',
                                 'type'        => __Type(),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getMutationType();
                                 },
                             ],
@@ -96,14 +96,14 @@ 
                                     'If this server support subscription, the type that ' .
                                     'subscription operations will be rooted at.',
                                 'type'        => __Type(),
-                                'resolve'     => function (Schema $schema): ?TypeInterface {
+                                'resolve'     => function(Schema $schema): ?TypeInterface {
                                     return $schema->getSubscriptionType();
                                 },
                             ],
                             'directives'       => [
                                 'description' => 'A list of all directives supported by this server.',
                                 'type'        => newNonNull(newList(newNonNull(__Directive()))),
-                                'resolve'     => function (Schema $schema): array {
+                                'resolve'     => function(Schema $schema): array {
                                     return $schema->getDirectives();
                                 },
                             ],
@@ -113,7 +113,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::DIRECTIVE_INTROSPECTION, function () {
+            ->share(GraphQL::DIRECTIVE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::DIRECTIVE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -124,7 +124,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(stringType())],
                             'description' => ['type' => stringType()],
@@ -133,7 +133,7 @@ 
                             ],
                             'args'        => [
                                 'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                                'resolve' => static function (Directive $directive): iterable {
+                                'resolve' => static function(Directive $directive): iterable {
                                     return $directive->getArguments() ?: [];
                                 },
                             ],
@@ -143,7 +143,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function () {
+            ->share(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function() {
                 return newEnumType([
                     'name'            => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                     'isIntrospection' => true,
@@ -213,7 +213,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::TYPE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -225,11 +225,11 @@ 
                         'Enum types provide their values. 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;
                                     }
@@ -265,7 +265,7 @@ 
                                 'args'    => [
                                     'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                 ],
-                                'resolve' => function (TypeInterface $type, array $args):
+                                'resolve' => function(TypeInterface $type, array $args):
                                 ?array {
                                     ['includeDeprecated' => $includeDeprecated] = $args;
 
@@ -273,7 +273,7 @@ 
                                         $fields = \array_values($type->getFields());
 
                                         if (!$includeDeprecated) {
-                                            $fields = \array_filter($fields, function (Field $field) {
+                                            $fields = \array_filter($fields, function(Field $field) {
                                                 return !$field->isDeprecated();
                                             });
                                         }
@@ -286,13 +286,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,
@@ -310,14 +310,14 @@ 
                                 'args'    => [
                                     'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                 ],
-                                'resolve' => function (TypeInterface $type, array $args): ?array {
+                                'resolve' => function(TypeInterface $type, array $args): ?array {
                                     ['includeDeprecated' => $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->isDeprecated();
                                             });
                                         }
@@ -330,7 +330,7 @@ 
                             ],
                             'inputFields'   => [
                                 'type'    => newList(newNonNull(__InputValue())),
-                                'resolve' => function (TypeInterface $type): ?array {
+                                'resolve' => function(TypeInterface $type): ?array {
                                     return $type instanceof InputObjectType ? $type->getFields() : null;
                                 },
                             ],
@@ -341,20 +341,20 @@ 
             });
 
         $this->container
-            ->share(GraphQL::FIELD_INTROSPECTION, function () {
+            ->share(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(stringType())],
                             'description'       => ['type' => stringType()],
                             'args'              => [
                                 'type'    => newNonNull(newList(newNonNull(__InputValue()))),
-                                'resolve' => function (ArgumentsAwareInterface $directive): array {
+                                'resolve' => function(ArgumentsAwareInterface $directive): array {
                                     return $directive->getArguments() ?? [];
                                 },
                             ],
@@ -367,7 +367,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -375,7 +375,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(stringType())],
                             'description'  => ['type' => stringType()],
@@ -385,7 +385,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;
                                 }
@@ -396,7 +396,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
+            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
                 return newObjectType([
                     'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
                     'isIntrospection' => true,
@@ -404,7 +404,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(stringType())],
                             'description'       => ['type' => stringType()],
@@ -416,7 +416,7 @@ 
             });
 
         $this->container
-            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function () {
+            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function() {
                 return newEnumType([
                     'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
                     'isIntrospection' => true,
@@ -457,12 +457,12 @@ 
     protected function registerMetaFields()
     {
         $this->container
-            ->share(GraphQL::SCHEMA_META_FIELD_DEFINITION, function ($__Schema) {
+            ->share(GraphQL::SCHEMA_META_FIELD_DEFINITION, function($__Schema) {
                 return newField([
                     'name'        => '__schema',
                     'description' => 'Access the current type schema of this server.',
                     'type'        => newNonNull($__Schema),
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): Schema {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): Schema {
                         return $info->getSchema();
                     },
                 ]);
@@ -470,13 +470,13 @@ 
             ->addArgument(GraphQL::SCHEMA_INTROSPECTION);
 
         $this->container
-            ->share(GraphQL::TYPE_META_FIELD_DEFINITION, function ($__Type) {
+            ->share(GraphQL::TYPE_META_FIELD_DEFINITION, function($__Type) {
                 return newField([
                     'name'        => '__type',
                     'description' => 'Request the type information of a single type.',
                     'type'        => $__Type,
                     'args'        => ['name' => ['type' => newNonNull(stringType())]],
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): ?TypeInterface {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): ?TypeInterface {
                         ['name' => $name] = $args;
                         return $info->getSchema()->getType($name);
                     },
@@ -485,12 +485,12 @@ 
             ->addArgument(GraphQL::TYPE_INTROSPECTION);
 
         $this->container
-            ->share(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function () {
+            ->share(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function() {
                 return newField([
                     'name'        => '__typename',
                     'description' => 'The name of the current Object type at runtime.',
                     'type'        => newNonNull(stringType()),
-                    'resolve'     => function ($source, $args, $context, ResolveInfo $info): string {
+                    'resolve'     => function($source, $args, $context, ResolveInfo $info): string {
                         return $info->getParentType()->getName();
                     },
                 ]);

src/Schema/Schema.php

Spacing +4 added lines, -4 removed lines

@@ -168,7 +168,7 @@ 
      */
     public function getDirective(string $name): ?DirectiveInterface
     {
-        return find($this->directives, static function (Directive $directive) use ($name) {
+        return find($this->directives, static function(Directive $directive) use ($name) {
             return $directive->getName() === $name;
         });
     }
@@ -224,7 +224,7 @@ 
 
             $this->possibleTypesMap[$abstractTypeName] = \array_reduce(
                 $possibleTypes,
-                static function (array $map, NamedTypeInterface $type) {
+                static function(array $map, NamedTypeInterface $type) {
                     $map[$type->getName()] = true;
 
                     return $map;
@@ -364,7 +364,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->getNullableType();
                         }, $field->getArguments());
 
@@ -398,7 +398,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->getNullableType());
         }, $map);
     }