Properly apply Schema changes for interface extension support

This redoes the work done for the Schema class since it was previously
guessed at. It now more closely follows graphql/graphql-js/pull/2084

Author: Kingdutch

src/Error/FormattedError.php

@@ -173,6 +173,8 @@ private static function lpad($len, $str)
      */
     public static function createFromException(Throwable $exception, int $debug = DebugFlag::NONE, $internalErrorMessage = null) : array
     {
+      var_dump($exception->getPrevious()->getMessage());
+      var_dump($exception->getPrevious()->getTraceAsString());
         $internalErrorMessage = $internalErrorMessage ?? self::$internalErrorMessage;
 
         if ($exception instanceof ClientAware) {

src/Executor/ReferenceExecutor.php

@@ -448,7 +448,7 @@ private function doesFragmentConditionMatch(Node $fragment, ObjectType $type) :
             return true;
         }
         if ($conditionalType instanceof AbstractType) {
-            return $this->exeContext->schema->isPossibleType($conditionalType, $type);
+            return $this->exeContext->schema->isSubType($conditionalType, $type);
         }
 
         return false;
@@ -1283,7 +1283,7 @@ private function ensureValidRuntimeType(
                 )
             );
         }
-        if (! $this->exeContext->schema->isPossibleType($returnType, $runtimeType)) {
+        if (! $this->exeContext->schema->isSubType($returnType, $runtimeType)) {
             throw new InvariantViolation(
                 sprintf('Runtime Object type "%s" is not a possible type for "%s".', $runtimeType, $returnType)
             );

src/Experimental/Executor/Collector.php

@@ -244,7 +244,7 @@ private function doCollectFields(ObjectType $runtimeType, ?SelectionSetNode $sel
                         continue;
                     }
                 } elseif ($conditionType instanceof AbstractType) {
-                    if (! $this->schema->isPossibleType($conditionType, $runtimeType)) {
+                    if (! $this->schema->isSubType($conditionType, $runtimeType)) {
                         continue;
                     }
                 }
@@ -269,7 +269,7 @@ private function doCollectFields(ObjectType $runtimeType, ?SelectionSetNode $sel
                             continue;
                         }
                     } elseif ($conditionType instanceof AbstractType) {
-                        if (! $this->schema->isPossibleType($conditionType, $runtimeType)) {
+                        if (! $this->schema->isSubType($conditionType, $runtimeType)) {
                             continue;
                         }
                     }

src/Experimental/Executor/CoroutineExecutor.php

@@ -745,7 +745,7 @@ private function completeValue(CoroutineContext $ctx, Type $type, $value, array
 
                         $returnValue = null;
                         goto CHECKED_RETURN;
-                    } elseif (! $this->schema->isPossibleType($type, $objectType)) {
+                    } elseif (! $this->schema->isSubType($type, $objectType)) {
                         $this->addError(Error::createLocatedError(
                             new InvariantViolation(sprintf(
                                 'Runtime Object type "%s" is not a possible type for "%s".',

src/Language/Parser.php

@@ -1627,8 +1627,7 @@ private function parseInterfaceTypeExtension() : InterfaceTypeExtensionNode
         $interfaces = $this->parseImplementsInterfaces();
         $directives = $this->parseDirectives(true);
         $fields     = $this->parseFieldsDefinition();
-        if (
-            count($interfaces) === 0 &&
+        if (count($interfaces) === 0 &&
             count($directives) === 0 &&
             count($fields) === 0
         ) {

src/Type/Schema.php

@@ -17,9 +17,11 @@
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Definition\UnionType;
+use GraphQL\Utils\InterfaceImplementations;
 use GraphQL\Utils\TypeInfo;
 use GraphQL\Utils\Utils;
 use Traversable;
+use function array_map;
 use function array_values;
 use function implode;
 use function is_array;
@@ -30,8 +32,8 @@
  * Schema Definition (see [related docs](type-system/schema.md))
  *
  * A Schema is created by supplying the root types of each type of operation:
- * query, mutation (optional) and subscription (optional). A schema definition is
- * then supplied to the validator and executor. Usage Example:
+ * query, mutation (optional) and subscription (optional). A schema definition
+ * is then supplied to the validator and executor. Usage Example:
  *
  *     $schema = new GraphQL\Type\Schema([
  *       'query' => $MyAppQueryRootType,
@@ -63,7 +65,14 @@ class Schema
      *
      * @var array<string, array<string, ObjectType|UnionType>>
      */
-    private $possibleTypeMap;
+    private $subTypeMap;
+
+    /**
+     * Lazily initialised
+     *
+     * @var array<string, InterfaceImplementations>
+     */
+    private $implementationsMap;
 
     /**
      * True when $resolvedTypes contain all possible schema types
@@ -190,10 +199,11 @@ private function resolveAdditionalTypes()
     }
 
     /**
-     * Returns array of all types in this schema. Keys of this array represent type names, values are instances
-     * of corresponding type definitions
+     * Returns array of all types in this schema. Keys of this array represent
+     * type names, values are instances of corresponding type definitions
      *
-     * This operation requires full schema scan. Do not use in production environment.
+     * This operation requires full schema scan. Do not use in production
+     * environment.
      *
      * @return Type[]
      *
@@ -407,7 +417,8 @@ public static function resolveType($type) : Type
      * Returns all possible concrete types for given abstract type
      * (implementations for interfaces and members of union type for unions)
      *
-     * This operation requires full schema scan. Do not use in production environment.
+     * This operation requires full schema scan. Do not use in production
+     * environment.
      *
      * @param InterfaceType|UnionType $abstractType
      *
@@ -427,45 +438,123 @@ public function getPossibleTypes(Type $abstractType) : array
      */
     private function getPossibleTypeMap() : array
     {
-        if (! isset($this->possibleTypeMap)) {
-            $this->possibleTypeMap = [];
+        if (! isset($this->subTypeMap)) {
+            $this->subTypeMap = [];
             foreach ($this->getTypeMap() as $type) {
                 if ($type instanceof ObjectType) {
                     foreach ($type->getInterfaces() as $interface) {
                         if (! ($interface instanceof InterfaceType)) {
                             continue;
                         }
 
-                        $this->possibleTypeMap[$interface->name][$type->name] = $type;
+                        $this->subTypeMap[$interface->name][$type->name] = $type;
                     }
                 } elseif ($type instanceof UnionType) {
                     foreach ($type->getTypes() as $innerType) {
-                        $this->possibleTypeMap[$type->name][$innerType->name] = $innerType;
+                        $this->subTypeMap[$type->name][$innerType->name] = $innerType;
+                    }
+                }
+            }
+        }
+
+        return $this->subTypeMap;
+    }
+
+    /**
+     * Returns all types that implement a given interface type.
+     *
+     * This operations requires full schema scan. Do not use in production
+     * environment.
+     *
+     * @api
+     */
+    public function getImplementations(InterfaceType $abstractType) : InterfaceImplementations
+    {
+        return $this->collectImplementations()[$abstractType->name];
+    }
+
+    /**
+     * @return array<string, InterfaceImplementations>
+     */
+    private function collectImplementations() : array
+    {
+        if (! isset($this->implementationsMap)) {
+            $foundImplementations = [];
+            foreach ($this->getTypeMap() as $type) {
+                if ($type instanceof InterfaceType) {
+                    if (! isset($foundImplementations[$type->name])) {
+                        $foundImplementations[$type->name] = ['objects' => [], 'interfaces' => []];
+                    }
+
+                    foreach ($type->getInterfaces() as $iface) {
+                        if (! isset($foundImplementations[$iface->name])) {
+                            $foundImplementations[$iface->name] = ['objects' => [], 'interfaces' => []];
+                        }
+                        $foundImplementations[$iface->name]['interfaces'][] = $type;
+                    }
+                } elseif ($type instanceof ObjectType) {
+                    foreach ($type->getInterfaces() as $iface) {
+                        if (! isset($foundImplementations[$iface->name])) {
+                            $foundImplementations[$iface->name] = ['objects' => [], 'interfaces' => []];
+                        }
+                        $foundImplementations[$iface->name]['objects'][] = $type;
                     }
                 }
             }
+            $this->implementationsMap = array_map(
+                static function (array $implementations) : InterfaceImplementations {
+                    return new InterfaceImplementations($implementations['objects'], $implementations['interfaces']);
+                },
+                $foundImplementations
+            );
         }
 
-        return $this->possibleTypeMap;
+        return $this->implementationsMap;
     }
 
     /**
+     * @deprecated as of 14.4.0 use isSubType instead, will be removed in 15.0.0.
+     *
      * Returns true if object type is concrete type of given abstract type
      * (implementation for interfaces and members of union type for unions)
      *
      * @api
+     * @codeCoverageIgnore
      */
-    public function isPossibleType(AbstractType $abstractType, ImplementingType $possibleType) : bool
+    public function isPossibleType(AbstractType $abstractType, ObjectType $possibleType) : bool
     {
-        if ($abstractType instanceof InterfaceType) {
-            return $possibleType->implementsInterface($abstractType);
-        }
+        return $this->isSubType($abstractType, $possibleType);
+    }
+
+    /**
+     * Returns true if maybe sub type is a sub type of given abstract type.
+     *
+     * @param UnionType|InterfaceType  $abstractType
+     * @param ObjectType|InterfaceType $maybeSubType
+     *
+     * @api
+     */
+    public function isSubType(AbstractType $abstractType, ImplementingType $maybeSubType) : bool
+    {
+        if (! isset($this->subTypeMap[$abstractType->name])) {
+            $this->subTypeMap[$abstractType->name] = [];
 
-        if ($abstractType instanceof UnionType) {
-            return $abstractType->isPossibleType($possibleType);
+            if ($abstractType instanceof UnionType) {
+                foreach ($abstractType->getTypes() as $type) {
+                    $this->subTypeMap[$abstractType->name][$type->name] = true;
+                }
+            } else {
+                $implementations = $this->getImplementations($abstractType);
+                foreach ($implementations->objects() as $type) {
+                    $this->subTypeMap[$abstractType->name][$type->name] = true;
+                }
+                foreach ($implementations->interfaces() as $type) {
+                    $this->subTypeMap[$abstractType->name][$type->name] = true;
+                }
+            }
         }
 
-        throw InvariantViolation::shouldNotHappen();
+        return isset($this->subTypeMap[$abstractType->name][$maybeSubType->name]);
     }
 
     /**
@@ -492,7 +581,8 @@ public function getAstNode() : ?SchemaDefinitionNode
     /**
      * Validates schema.
      *
-     * This operation requires full schema scan. Do not use in production environment.
+     * This operation requires full schema scan. Do not use in production
+     * environment.
      *
      * @throws InvariantViolation
      *
@@ -532,7 +622,8 @@ public function assertValid()
     /**
      * Validates schema.
      *
-     * This operation requires full schema scan. Do not use in production environment.
+     * This operation requires full schema scan. Do not use in production
+     * environment.
      *
      * @return InvariantViolation[]|Error[]
      *

src/Type/SchemaValidationContext.php

@@ -44,6 +44,7 @@
 use function array_key_exists;
 use function array_merge;
 use function count;
+use function in_array;
 use function is_array;
 use function is_object;
 use function sprintf;
@@ -676,6 +677,18 @@ private function validateInterfaces(ImplementingType $type)
                 );
                 continue;
             }
+
+            if ($type === $iface) {
+              $this->reportError(
+                sprintf(
+                  'Type %s cannot implement itself because it would create a circular reference.',
+                  $type->name
+                ),
+                $this->getImplementsInterfaceNode($type, $iface)
+              );
+              continue;
+            }
+
             if (isset($ifaceTypeNames[$iface->name])) {
                 $this->reportError(
                     sprintf('Type %s can only implement %s once.', $type->name, $iface->name),
@@ -883,29 +896,33 @@ private function validateTypeImplementsInterface($type, $iface)
      * @param ObjectType|InterfaceType $type
      * @param InterfaceType            $iface
      */
-    private function validateTypeImplementsAncestors(ImplementingType $type, $iface) {
+    private function validateTypeImplementsAncestors(ImplementingType $type, $iface)
+    {
         $typeInterfaces = $type->getInterfaces();
         foreach ($iface->getInterfaces() as $transitive) {
-            if (!in_array($transitive, $typeInterfaces)) {
-                $this->reportError(
-                    $transitive === $type ?
-                        sprintf(
-                            "Type %s cannot implement %s because it would create a circular reference.",
-                            $type->name,
-                            $iface->name
-                        ) :
-                        sprintf(
-                            "Type %s must implement %s because it is implemented by %s.",
-                            $type->name,
-                            $transitive->name,
-                            $iface->name
-                        ),
-                    array_merge(
-                        $this->getAllImplementsInterfaceNodes($iface, $transitive),
-                        $this->getAllImplementsInterfaceNodes($type, $iface)
-                    )
-                );
+            if (in_array($transitive, $typeInterfaces, true)) {
+                continue;
             }
+
+            $error = $transitive === $type ?
+                sprintf(
+                    'Type %s cannot implement %s because it would create a circular reference.',
+                    $type->name,
+                    $iface->name
+                ) :
+                sprintf(
+                    'Type %s must implement %s because it is implemented by %s.',
+                    $type->name,
+                    $transitive->name,
+                    $iface->name
+                );
+            $this->reportError(
+                $error,
+                array_merge(
+                    $this->getAllImplementsInterfaceNodes($iface, $transitive),
+                    $this->getAllImplementsInterfaceNodes($type, $iface)
+                )
+            );
         }
     }