Fix variable validation failing when type loader overrides built-in scalars

When a type loader returns a custom instance for a built-in scalar (e.g.
ID, String), `Schema::getType()` stores and returns that instance. However,
field argument definitions in the schema still reference the built-in
singletons (e.g. `Type::id()`). During query validation,
`VariablesInAllowedPosition` resolves variable types via
`Schema::getType()` and compares them against argument types using
`TypeComparators`. Both `isEqualType()` and `isTypeSubTypeOf()` use strict
identity checks (`===`), which fail when comparing two different instances
that represent the same named type.

This causes queries with variables of overridden built-in scalar types to
fail validation with errors like:

  Variable "$id" of type "ID!" used in position expecting type "ID!".

The fix adds a name-based equality check for `NamedType` instances in both
`isEqualType()` and `isTypeSubTypeOf()`, falling back to comparing type
names when the identity check fails. In a valid schema, each type name is
unique, so two named types with the same name are semantically equivalent
even if they are different object instances.

Ref webonyx#1869
Fixes webonyx#1874

Author: ruudk

src/Utils/TypeComparators.php

@@ -5,6 +5,7 @@
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Type\Definition\ImplementingType;
 use GraphQL\Type\Definition\ListOfType;
+use GraphQL\Type\Definition\NamedType;
 use GraphQL\Type\Definition\NonNull;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Schema;
@@ -19,6 +20,14 @@ public static function isEqualType(Type $typeA, Type $typeB): bool
             return true;
         }
 
+        // Named types with the same name are equal, even if they are different
+        // instances (e.g. a type loader override vs the built-in singleton).
+        if ($typeA instanceof NamedType && $typeB instanceof NamedType
+            && $typeA->name() === $typeB->name()
+        ) {
+            return true;
+        }
+
         // If either type is non-null, the other must also be non-null.
         if ($typeA instanceof NonNull && $typeB instanceof NonNull) {
             return self::isEqualType($typeA->getWrappedType(), $typeB->getWrappedType());
@@ -46,6 +55,14 @@ public static function isTypeSubTypeOf(Schema $schema, Type $maybeSubType, Type
             return true;
         }
 
+        // Named types with the same name are equivalent, even if they are different
+        // instances (e.g. a type loader override vs the built-in singleton).
+        if ($maybeSubType instanceof NamedType && $superType instanceof NamedType
+            && $maybeSubType->name() === $superType->name()
+        ) {
+            return true;
+        }
+
         // If superType is non-null, maybeSubType must also be nullable.
         if ($superType instanceof NonNull) {
             if ($maybeSubType instanceof NonNull) {

tests/Type/ScalarOverridesTest.php

@@ -5,6 +5,7 @@
 use GraphQL\Error\InvariantViolation;
 use GraphQL\GraphQL;
 use GraphQL\Type\Definition\CustomScalarType;
+use GraphQL\Type\Definition\NonNull;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\ScalarType;
 use GraphQL\Type\Definition\Type;
@@ -204,6 +205,70 @@ public function testNonOverriddenScalarsAreUnaffected(): void
         self::assertSame('abc-123', $data['identifier']);
     }
 
+    public function testTypeLoaderOverrideWithVariableOfOverriddenBuiltInScalarType(): void
+    {
+        $customID = new CustomScalarType([
+            'name' => Type::ID,
+            'serialize' => static fn ($value): string => (string) $value,
+            'parseValue' => static fn ($value): string => (string) $value,
+        ]);
+
+        $queryType = new ObjectType([
+            'name' => 'Query',
+            'fields' => [
+                'node' => [
+                    'type' => Type::string(),
+                    'args' => [
+                        'id' => Type::nonNull(Type::id()),
+                    ],
+                    'resolve' => static fn ($root, array $args): string => 'node-' . $args['id'],
+                ],
+            ],
+        ]);
+
+        $types = ['Query' => $queryType, 'ID' => $customID];
+
+        $schema = new Schema([
+            'query' => $queryType,
+            'typeLoader' => static fn (string $name): ?Type => $types[$name] ?? null,
+        ]);
+
+        $result = GraphQL::executeQuery($schema, 'query ($id: ID!) { node(id: $id) }', null, null, ['id' => 'abc-123']);
+
+        self::assertEmpty($result->errors, isset($result->errors[0]) ? $result->errors[0]->getMessage() : '');
+        self::assertSame(['data' => ['node' => 'node-abc-123']], $result->toArray());
+    }
+
+    public function testTypeLoaderOverrideWithNullableVariableOfOverriddenBuiltInScalarType(): void
+    {
+        $customString = self::createUppercaseString();
+
+        $queryType = new ObjectType([
+            'name' => 'Query',
+            'fields' => [
+                'echo' => [
+                    'type' => Type::string(),
+                    'args' => [
+                        'text' => Type::string(),
+                    ],
+                    'resolve' => static fn ($root, array $args): ?string => $args['text'] ?? null,
+                ],
+            ],
+        ]);
+
+        $types = ['Query' => $queryType, 'String' => $customString];
+
+        $schema = new Schema([
+            'query' => $queryType,
+            'typeLoader' => static fn (string $name): ?Type => $types[$name] ?? null,
+        ]);
+
+        $result = GraphQL::executeQuery($schema, 'query ($text: String) { echo(text: $text) }', null, null, ['text' => 'hello']);
+
+        self::assertEmpty($result->errors, isset($result->errors[0]) ? $result->errors[0]->getMessage() : '');
+        self::assertSame(['data' => ['echo' => 'HELLO']], $result->toArray());
+    }
+
     /** @throws InvariantViolation */
     private static function createUppercaseString(): CustomScalarType
     {