Completed
Pull Request — master (#270)
by Christoffer
02:11
created
src/Error/GraphQLException.php 1 patch
Spacing   +5 added lines, -5 removed lines patch added patch discarded remove patch
@@ -152,7 +152,7 @@  discard block
 block discarded – undo
152 152
      */
153 153
     public function getLocationsAsArray(): ?array
154 154
     {
155
-        return !empty($this->locations) ? \array_map(function (SourceLocation $location) {
155
+        return !empty($this->locations) ? \array_map(function(SourceLocation $location) {
156 156
             return $location->toArray();
157 157
         }, $this->locations) : null;
158 158
     }
@@ -193,7 +193,7 @@  discard block
 block discarded – undo
193 193
             $nodes = [$nodes];
194 194
         }
195 195
 
196
-        $this->nodes = \array_filter($nodes, function ($node) {
196
+        $this->nodes = \array_filter($nodes, function($node) {
197 197
             return null !== $node;
198 198
         });
199 199
 
@@ -224,7 +224,7 @@  discard block
 block discarded – undo
224 224
     protected function resolvePositions(?array $positions)
225 225
     {
226 226
         if (null === $positions && !empty($this->nodes)) {
227
-            $positions = \array_reduce($this->nodes, function (array $list, ?NodeInterface $node) {
227
+            $positions = \array_reduce($this->nodes, function(array $list, ?NodeInterface $node) {
228 228
                 if (null !== $node) {
229 229
                     $location = $node->getLocation();
230 230
                     if (null !== $location) {
@@ -252,11 +252,11 @@  discard block
 block discarded – undo
252 252
     protected function resolveLocations(?array $positions, ?Source $source)
253 253
     {
254 254
         if (null !== $positions && null !== $source) {
255
-            $locations = \array_map(function ($position) use ($source) {
255
+            $locations = \array_map(function($position) use ($source) {
256 256
                 return SourceLocation::fromSource($source, $position);
257 257
             }, $positions);
258 258
         } elseif (!empty($this->nodes)) {
259
-            $locations = \array_reduce($this->nodes, function (array $list, NodeInterface $node) {
259
+            $locations = \array_reduce($this->nodes, function(array $list, NodeInterface $node) {
260 260
                 $location = $node->getLocation();
261 261
                 if (null !== $location) {
262 262
                     $list[] = SourceLocation::fromSource($location->getSource(), $location->getStart());
Please login to merge, or discard this patch.
src/Schema/DefinitionBuilder.php 1 patch
Spacing   +19 added lines, -19 removed lines patch added patch discarded remove patch
@@ -107,7 +107,7 @@  discard block
 block discarded – undo
107 107
      */
108 108
     public function buildTypes(array $nodes): array
109 109
     {
110
-        return \array_map(function (NodeInterface $node) {
110
+        return \array_map(function(NodeInterface $node) {
111 111
             return $this->buildType($node);
112 112
         }, $nodes);
113 113
     }
@@ -158,7 +158,7 @@  discard block
 block discarded – undo
158 158
         $directive = newDirective([
159 159
             'name'        => $node->getNameValue(),
160 160
             'description' => $node->getDescriptionValue(),
161
-            'locations'   => \array_map(function (NameNode $node) {
161
+            'locations'   => \array_map(function(NameNode $node) {
162 162
                 return $node->getValue();
163 163
             }, $node->getLocations()),
164 164
             'args'        => $node->hasArguments() ? $this->buildArguments($node->getArguments()) : [],
@@ -226,7 +226,7 @@  discard block
 block discarded – undo
226 226
     {
227 227
         $typesMap = keyMap(
228 228
             \array_merge($customTypes, specifiedScalarTypes(), introspectionTypes()),
229
-            function (NamedTypeInterface $type) {
229
+            function(NamedTypeInterface $type) {
230 230
                 return $type->getName();
231 231
             }
232 232
         );
@@ -243,7 +243,7 @@  discard block
 block discarded – undo
243 243
     {
244 244
         $directivesMap = keyMap(
245 245
             \array_merge($customDirectives, specifiedDirectives()),
246
-            function (Directive $directive) {
246
+            function(Directive $directive) {
247 247
                 return $directive->getName();
248 248
             }
249 249
         );
@@ -262,10 +262,10 @@  discard block
 block discarded – undo
262 262
     {
263 263
         return keyValueMap(
264 264
             $nodes,
265
-            function (InputValueDefinitionNode $value) {
265
+            function(InputValueDefinitionNode $value) {
266 266
                 return $value->getNameValue();
267 267
             },
268
-            function (InputValueDefinitionNode $value): array {
268
+            function(InputValueDefinitionNode $value): array {
269 269
                 $type         = $this->buildWrappedType($value->getType());
270 270
                 $defaultValue = $value->getDefaultValue();
271 271
                 return [
@@ -319,14 +319,14 @@  discard block
 block discarded – undo
319 319
         return newObjectType([
320 320
             'name'        => $node->getNameValue(),
321 321
             'description' => $node->getDescriptionValue(),
322
-            'fields'      => $node->hasFields() ? function () use ($node) {
322
+            'fields'      => $node->hasFields() ? function() use ($node) {
323 323
                 return $this->buildFields($node);
324 324
             } : [],
325 325
             // Note: While this could make early assertions to get the correctly
326 326
             // typed values, that would throw immediately while type system
327 327
             // validation with validateSchema() will produce more actionable results.
328
-            'interfaces'  => function () use ($node) {
329
-                return $node->hasInterfaces() ? \array_map(function (NodeInterface $interface) {
328
+            'interfaces'  => function() use ($node) {
329
+                return $node->hasInterfaces() ? \array_map(function(NodeInterface $interface) {
330 330
                     return $this->buildType($interface);
331 331
                 }, $node->getInterfaces()) : [];
332 332
             },
@@ -342,11 +342,11 @@  discard block
 block discarded – undo
342 342
     {
343 343
         return keyValueMap(
344 344
             $node->getFields(),
345
-            function ($value) {
345
+            function($value) {
346 346
                 /** @var FieldDefinitionNode|InputValueDefinitionNode $value */
347 347
                 return $value->getNameValue();
348 348
             },
349
-            function ($value) use ($node) {
349
+            function($value) use ($node) {
350 350
                 /** @var FieldDefinitionNode|InputValueDefinitionNode $value */
351 351
                 return $this->buildField($value,
352 352
                     $this->getFieldResolver($node->getNameValue(), $value->getNameValue()));
@@ -376,7 +376,7 @@  discard block
 block discarded – undo
376 376
         return newInterfaceType([
377 377
             'name'        => $node->getNameValue(),
378 378
             'description' => $node->getDescriptionValue(),
379
-            'fields'      => $node->hasFields() ? function () use ($node): array {
379
+            'fields'      => $node->hasFields() ? function() use ($node) : array {
380 380
                 return $this->buildFields($node);
381 381
             } : [],
382 382
             'resolveType' => $this->getTypeResolver($node->getNameValue()),
@@ -396,10 +396,10 @@  discard block
 block discarded – undo
396 396
             'description' => $node->getDescriptionValue(),
397 397
             'values'      => $node->hasValues() ? keyValueMap(
398 398
                 $node->getValues(),
399
-                function (EnumValueDefinitionNode $value): ?string {
399
+                function(EnumValueDefinitionNode $value): ?string {
400 400
                     return $value->getNameValue();
401 401
                 },
402
-                function (EnumValueDefinitionNode $value): array {
402
+                function(EnumValueDefinitionNode $value): array {
403 403
                     return [
404 404
                         'description'       => $value->getDescriptionValue(),
405 405
                         'deprecationReason' => $this->getDeprecationReason($value),
@@ -421,7 +421,7 @@  discard block
 block discarded – undo
421 421
         return newUnionType([
422 422
             'name'        => $node->getNameValue(),
423 423
             'description' => $node->getDescriptionValue(),
424
-            'types'       => $node->hasTypes() ? \array_map(function (NodeInterface $type) {
424
+            'types'       => $node->hasTypes() ? \array_map(function(NodeInterface $type) {
425 425
                 return $this->buildType($type);
426 426
             }, $node->getTypes()) : [],
427 427
             'resolveType' => $this->getTypeResolver($node->getNameValue()),
@@ -450,7 +450,7 @@  discard block
 block discarded – undo
450 450
         return newScalarType([
451 451
             'name'        => $node->getNameValue(),
452 452
             'description' => $node->getDescriptionValue(),
453
-            'serialize'   => function ($value) {
453
+            'serialize'   => function($value) {
454 454
                 return $value;
455 455
             },
456 456
             'astNode'     => $node,
@@ -467,13 +467,13 @@  discard block
 block discarded – undo
467 467
         return newInputObjectType([
468 468
             'name'        => $node->getNameValue(),
469 469
             'description' => $node->getDescriptionValue(),
470
-            'fields'      => $node->hasFields() ? function () use ($node) {
470
+            'fields'      => $node->hasFields() ? function() use ($node) {
471 471
                 return keyValueMap(
472 472
                     $node->getFields(),
473
-                    function (InputValueDefinitionNode $value): ?string {
473
+                    function(InputValueDefinitionNode $value): ?string {
474 474
                         return $value->getNameValue();
475 475
                     },
476
-                    function (InputValueDefinitionNode $value): array {
476
+                    function(InputValueDefinitionNode $value): array {
477 477
                         $type         = $this->buildWrappedType($value->getType());
478 478
                         $defaultValue = $value->getDefaultValue();
479 479
                         return [
Please login to merge, or discard this patch.
src/Type/IntrospectionProvider.php 1 patch
Spacing   +36 added lines, -36 removed lines patch added patch discarded remove patch
@@ -57,7 +57,7 @@  discard block
 block discarded – undo
57 57
      */
58 58
     protected function registerIntrospectionTypes()
59 59
     {
60
-        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function () {
60
+        $this->container->add(GraphQL::SCHEMA_INTROSPECTION, function() {
61 61
             return newObjectType([
62 62
                 'name'            => GraphQL::SCHEMA_INTROSPECTION,
63 63
                 'isIntrospection' => true,
@@ -65,19 +65,19 @@  discard block
 block discarded – undo
65 65
                     'A GraphQL Schema defines the capabilities of a GraphQL server. It ' .
66 66
                     'exposes all available types and directives on the server, as well as ' .
67 67
                     'the entry points for query, mutation, and subscription operations.',
68
-                'fields'          => function () {
68
+                'fields'          => function() {
69 69
                     return [
70 70
                         'types'            => [
71 71
                             'description' => 'A list of all types supported by this server.',
72 72
                             'type'        => newNonNull(newList(newNonNull(__Type()))),
73
-                            'resolve'     => function (Schema $schema): array {
73
+                            'resolve'     => function(Schema $schema): array {
74 74
                                 return \array_values($schema->getTypeMap());
75 75
                             },
76 76
                         ],
77 77
                         'queryType'        => [
78 78
                             'description' => 'The type that query operations will be rooted at.',
79 79
                             'type'        => newNonNull(__Type()),
80
-                            'resolve'     => function (Schema $schema): ?TypeInterface {
80
+                            'resolve'     => function(Schema $schema): ?TypeInterface {
81 81
                                 return $schema->getQueryType();
82 82
                             },
83 83
                         ],
@@ -86,7 +86,7 @@  discard block
 block discarded – undo
86 86
                                 'If this server supports mutation, the type that ' .
87 87
                                 'mutation operations will be rooted at.',
88 88
                             'type'        => __Type(),
89
-                            'resolve'     => function (Schema $schema): ?TypeInterface {
89
+                            'resolve'     => function(Schema $schema): ?TypeInterface {
90 90
                                 return $schema->getMutationType();
91 91
                             },
92 92
                         ],
@@ -95,14 +95,14 @@  discard block
 block discarded – undo
95 95
                                 'If this server support subscription, the type that ' .
96 96
                                 'subscription operations will be rooted at.',
97 97
                             'type'        => __Type(),
98
-                            'resolve'     => function (Schema $schema): ?TypeInterface {
98
+                            'resolve'     => function(Schema $schema): ?TypeInterface {
99 99
                                 return $schema->getSubscriptionType();
100 100
                             },
101 101
                         ],
102 102
                         'directives'       => [
103 103
                             'description' => 'A list of all directives supported by this server.',
104 104
                             'type'        => newNonNull(newList(newNonNull(__Directive()))),
105
-                            'resolve'     => function (Schema $schema): array {
105
+                            'resolve'     => function(Schema $schema): array {
106 106
                                 return $schema->getDirectives();
107 107
                             },
108 108
                         ],
@@ -111,7 +111,7 @@  discard block
 block discarded – undo
111 111
             ]);
112 112
         }, true/* $shared */);
113 113
 
114
-        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function () {
114
+        $this->container->add(GraphQL::DIRECTIVE_INTROSPECTION, function() {
115 115
             return newObjectType([
116 116
                 'name'            => GraphQL::DIRECTIVE_INTROSPECTION,
117 117
                 'isIntrospection' => true,
@@ -122,7 +122,7 @@  discard block
 block discarded – undo
122 122
                     'execution behavior in ways field arguments will not suffice, such as ' .
123 123
                     'conditionally including or skipping a field. Directives provide this by ' .
124 124
                     'describing additional information to the executor.',
125
-                'fields'          => function () {
125
+                'fields'          => function() {
126 126
                     return [
127 127
                         'name'        => ['type' => newNonNull(String())],
128 128
                         'description' => ['type' => String()],
@@ -131,7 +131,7 @@  discard block
 block discarded – undo
131 131
                         ],
132 132
                         'args'        => [
133 133
                             'type'    => newNonNull(newList(newNonNull(__InputValue()))),
134
-                            'resolve' => function (Directive $directive): array {
134
+                            'resolve' => function(Directive $directive): array {
135 135
                                 return $directive->getArguments() ?: [];
136 136
                             },
137 137
                         ],
@@ -140,7 +140,7 @@  discard block
 block discarded – undo
140 140
             ]);
141 141
         }, true/* $shared */);
142 142
 
143
-        $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function () {
143
+        $this->container->add(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function() {
144 144
             return newEnumType([
145 145
                 'name'            => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
146 146
                 'isIntrospection' => true,
@@ -206,7 +206,7 @@  discard block
 block discarded – undo
206 206
             ]);
207 207
         }, true/* $shared */);
208 208
 
209
-        $this->container->add(GraphQL::TYPE_INTROSPECTION, function () {
209
+        $this->container->add(GraphQL::TYPE_INTROSPECTION, function() {
210 210
             return newObjectType([
211 211
                 'name'            => GraphQL::TYPE_INTROSPECTION,
212 212
                 'isIntrospection' => true,
@@ -219,11 +219,11 @@  discard block
 block discarded – undo
219 219
                     'Object and Interface types provide the fields they describe. Abstract ' .
220 220
                     'types, Union and Interface, provide the Object types possible ' .
221 221
                     'at runtime. List and NonNull types compose other types.',
222
-                'fields'          => function () {
222
+                'fields'          => function() {
223 223
                     return [
224 224
                         'kind'          => [
225 225
                             'type'    => newNonNull(__TypeKind()),
226
-                            'resolve' => function (TypeInterface $type) {
226
+                            'resolve' => function(TypeInterface $type) {
227 227
                                 if ($type instanceof ScalarType) {
228 228
                                     return TypeKindEnum::SCALAR;
229 229
                                 }
@@ -259,7 +259,7 @@  discard block
 block discarded – undo
259 259
                             'args'    => [
260 260
                                 'includeDeprecated' => ['type' => Boolean(), 'defaultValue' => false],
261 261
                             ],
262
-                            'resolve' => function (TypeInterface $type, array $args):
262
+                            'resolve' => function(TypeInterface $type, array $args):
263 263
                             ?array {
264 264
                                 ['includeDeprecated' => $includeDeprecated] = $args;
265 265
 
@@ -267,7 +267,7 @@  discard block
 block discarded – undo
267 267
                                     $fields = \array_values($type->getFields());
268 268
 
269 269
                                     if (!$includeDeprecated) {
270
-                                        $fields = \array_filter($fields, function (Field $field) {
270
+                                        $fields = \array_filter($fields, function(Field $field) {
271 271
                                             return !$field->isDeprecated();
272 272
                                         });
273 273
                                     }
@@ -280,13 +280,13 @@  discard block
 block discarded – undo
280 280
                         ],
281 281
                         'interfaces'    => [
282 282
                             'type'    => newList(newNonNull(__Type())),
283
-                            'resolve' => function (TypeInterface $type): ?array {
283
+                            'resolve' => function(TypeInterface $type): ?array {
284 284
                                 return $type instanceof ObjectType ? $type->getInterfaces() : null;
285 285
                             },
286 286
                         ],
287 287
                         'possibleTypes' => [
288 288
                             'type'    => newList(newNonNull(__Type())),
289
-                            'resolve' => function (
289
+                            'resolve' => function(
290 290
                                 TypeInterface $type,
291 291
                                 array $args,
292 292
                                 array $context,
@@ -304,14 +304,14 @@  discard block
 block discarded – undo
304 304
                             'args'    => [
305 305
                                 'includeDeprecated' => ['type' => Boolean(), 'defaultValue' => false],
306 306
                             ],
307
-                            'resolve' => function (TypeInterface $type, array $args): ?array {
307
+                            'resolve' => function(TypeInterface $type, array $args): ?array {
308 308
                                 ['includeDeprecated' => $includeDeprecated] = $args;
309 309
 
310 310
                                 if ($type instanceof EnumType) {
311 311
                                     $values = \array_values($type->getValues());
312 312
 
313 313
                                     if (!$includeDeprecated) {
314
-                                        $values = \array_filter($values, function (Field $field) {
314
+                                        $values = \array_filter($values, function(Field $field) {
315 315
                                             return !$field->isDeprecated();
316 316
                                         });
317 317
                                     }
@@ -324,7 +324,7 @@  discard block
 block discarded – undo
324 324
                         ],
325 325
                         'inputFields'   => [
326 326
                             'type'    => newList(newNonNull(__InputValue())),
327
-                            'resolve' => function (TypeInterface $type): ?array {
327
+                            'resolve' => function(TypeInterface $type): ?array {
328 328
                                 return $type instanceof InputObjectType ? $type->getFields() : null;
329 329
                             },
330 330
                         ],
@@ -334,20 +334,20 @@  discard block
 block discarded – undo
334 334
             ]);
335 335
         }, true/* $shared */);
336 336
 
337
-        $this->container->add(GraphQL::FIELD_INTROSPECTION, function () {
337
+        $this->container->add(GraphQL::FIELD_INTROSPECTION, function() {
338 338
             return newObjectType([
339 339
                 'name'            => GraphQL::FIELD_INTROSPECTION,
340 340
                 'isIntrospection' => true,
341 341
                 'description'     =>
342 342
                     'Object and Interface types are described by a list of Fields, each of ' .
343 343
                     'which has a name, potentially a list of arguments, and a return type.',
344
-                'fields'          => function () {
344
+                'fields'          => function() {
345 345
                     return [
346 346
                         'name'              => ['type' => newNonNull(String())],
347 347
                         'description'       => ['type' => String()],
348 348
                         'args'              => [
349 349
                             'type'    => newNonNull(newList(newNonNull(__InputValue()))),
350
-                            'resolve' => function (ArgumentsAwareInterface $directive): array {
350
+                            'resolve' => function(ArgumentsAwareInterface $directive): array {
351 351
                                 return $directive->getArguments() ?? [];
352 352
                             },
353 353
                         ],
@@ -359,7 +359,7 @@  discard block
 block discarded – undo
359 359
             ]);
360 360
         }, true/* $shared */);
361 361
 
362
-        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
362
+        $this->container->add(GraphQL::INPUT_VALUE_INTROSPECTION, function() {
363 363
             return newObjectType([
364 364
                 'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
365 365
                 'isIntrospection' => true,
@@ -367,7 +367,7 @@  discard block
 block discarded – undo
367 367
                     'Arguments provided to Fields or Directives and the input fields of an ' .
368 368
                     'InputObject are represented as Input Values which describe their type ' .
369 369
                     'and optionally a default value.',
370
-                'fields'          => function () {
370
+                'fields'          => function() {
371 371
                     return [
372 372
                         'name'         => ['type' => newNonNull(String())],
373 373
                         'description'  => ['type' => String()],
@@ -377,7 +377,7 @@  discard block
 block discarded – undo
377 377
                             'description' =>
378 378
                                 'A GraphQL-formatted string representing the default value for this ' .
379 379
                                 'input value.',
380
-                            'resolve'     => function (/*$inputValue*/) {
380
+                            'resolve'     => function(/*$inputValue*/) {
381 381
                                 // TODO: Implement this when we have support for printing AST.
382 382
                                 return null;
383 383
                             }
@@ -387,7 +387,7 @@  discard block
 block discarded – undo
387 387
             ]);
388 388
         }, true/* $shared */);
389 389
 
390
-        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
390
+        $this->container->add(GraphQL::ENUM_VALUE_INTROSPECTION, function() {
391 391
             return newObjectType([
392 392
                 'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
393 393
                 'isIntrospection' => true,
@@ -395,7 +395,7 @@  discard block
 block discarded – undo
395 395
                     'One possible value for a given Enum. Enum values are unique values, not ' .
396 396
                     'a placeholder for a string or numeric value. However an Enum value is ' .
397 397
                     'returned in a JSON response as a string.',
398
-                'fields'          => function () {
398
+                'fields'          => function() {
399 399
                     return [
400 400
                         'name'              => ['type' => newNonNull(String())],
401 401
                         'description'       => ['type' => String()],
@@ -406,7 +406,7 @@  discard block
 block discarded – undo
406 406
             ]);
407 407
         }, true/* $shared */);
408 408
 
409
-        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function () {
409
+        $this->container->add(GraphQL::TYPE_KIND_INTROSPECTION, function() {
410 410
             return newEnumType([
411 411
                 'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
412 412
                 'isIntrospection' => true,
@@ -446,25 +446,25 @@  discard block
 block discarded – undo
446 446
      */
447 447
     protected function registerMetaFields()
448 448
     {
449
-        $this->container->add(GraphQL::SCHEMA_META_FIELD_DEFINITION, function ($__Schema) {
449
+        $this->container->add(GraphQL::SCHEMA_META_FIELD_DEFINITION, function($__Schema) {
450 450
             return newField([
451 451
                 'name'        => '__schema',
452 452
                 'description' => 'Access the current type schema of this server.',
453 453
                 'type'        => newNonNull($__Schema),
454
-                'resolve'     => function ($source, $args, $context, ResolveInfo $info): Schema {
454
+                'resolve'     => function($source, $args, $context, ResolveInfo $info): Schema {
455 455
                     return $info->getSchema();
456 456
                 },
457 457
             ]);
458 458
         })
459 459
             ->withArgument(GraphQL::SCHEMA_INTROSPECTION);
460 460
 
461
-        $this->container->add(GraphQL::TYPE_META_FIELD_DEFINITION, function ($__Type) {
461
+        $this->container->add(GraphQL::TYPE_META_FIELD_DEFINITION, function($__Type) {
462 462
             return newField([
463 463
                 'name'        => '__type',
464 464
                 'description' => 'Request the type information of a single type.',
465 465
                 'type'        => $__Type,
466 466
                 'args'        => ['name' => ['type' => newNonNull(String())]],
467
-                'resolve'     => function ($source, $args, $context, ResolveInfo $info): ?TypeInterface {
467
+                'resolve'     => function($source, $args, $context, ResolveInfo $info): ?TypeInterface {
468 468
                     ['name' => $name] = $args;
469 469
                     return $info->getSchema()->getType($name);
470 470
                 },
@@ -472,12 +472,12 @@  discard block
 block discarded – undo
472 472
         })
473 473
             ->withArgument(GraphQL::TYPE_INTROSPECTION);
474 474
 
475
-        $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function () {
475
+        $this->container->add(GraphQL::TYPE_NAME_META_FIELD_DEFINITION, function() {
476 476
             return newField([
477 477
                 'name'        => '__typename',
478 478
                 'description' => 'The name of the current Object type at runtime.',
479 479
                 'type'        => newNonNull(String()),
480
-                'resolve'     => function ($source, $args, $context, ResolveInfo $info): string {
480
+                'resolve'     => function($source, $args, $context, ResolveInfo $info): string {
481 481
                     return $info->getParentType()->getName();
482 482
                 },
483 483
             ]);
Please login to merge, or discard this patch.