Implement support for interfaces implementing interfaces

Closes #728

src/Language/AST/InterfaceTypeDefinitionNode.php

@@ -15,6 +15,9 @@ class InterfaceTypeDefinitionNode extends Node implements TypeDefinitionNode
     /** @var NodeList<DirectiveNode>|null */
     public $directives;
 
+    /** @var NodeList<InterfaceTypeDefinitionNode>|null */
+    public $interfaces;
+
     /** @var NodeList<FieldDefinitionNode>|null */
     public $fields;
 

src/Language/AST/InterfaceTypeExtensionNode.php

@@ -15,6 +15,9 @@ class InterfaceTypeExtensionNode extends Node implements TypeExtensionNode
     /** @var NodeList<DirectiveNode>|null */
     public $directives;
 
+    /** @var NodeList<InterfaceTypeDefinitionNode>|null */
+    public $interfaces;
+
     /** @var NodeList<FieldDefinitionNode>|null */
     public $fields;
 }

src/Language/Parser.php

@@ -1346,12 +1346,14 @@ private function parseInterfaceTypeDefinition() : InterfaceTypeDefinitionNode
         $description = $this->parseDescription();
         $this->expectKeyword('interface');
         $name       = $this->parseName();
+        $interfaces = $this->parseImplementsInterfaces();
         $directives = $this->parseDirectives(true);
         $fields     = $this->parseFieldsDefinition();
 
         return new InterfaceTypeDefinitionNode([
             'name'        => $name,
             'directives'  => $directives,
+            'interfaces'  => $interfaces,
             'fields'      => $fields,
             'loc'         => $this->loc($start),
             'description' => $description,
@@ -1622,6 +1624,7 @@ private function parseInterfaceTypeExtension() : InterfaceTypeExtensionNode
         $this->expectKeyword('extend');
         $this->expectKeyword('interface');
         $name       = $this->parseName();
+        $interfaces = $this->parseImplementsInterfaces();
         $directives = $this->parseDirectives(true);
         $fields     = $this->parseFieldsDefinition();
         if (count($directives) === 0 &&
@@ -1633,6 +1636,7 @@ private function parseInterfaceTypeExtension() : InterfaceTypeExtensionNode
         return new InterfaceTypeExtensionNode([
             'name'       => $name,
             'directives' => $directives,
+            'interfaces'  => $interfaces,
             'fields'     => $fields,
             'loc'        => $this->loc($start),
         ]);

src/Language/Printer.php

@@ -309,6 +309,7 @@ function (InterfaceTypeDefinitionNode $def) : string {
                                 [
                                     'interface',
                                     $def->name,
+                                    $this->wrap('implements ', $this->join($def->interfaces, ' & ')),
                                     $this->join($def->directives, ' '),
                                     $this->block($def->fields),
                                 ],
@@ -401,6 +402,7 @@ function (InterfaceTypeDefinitionNode $def) : string {
                             [
                                 'extend interface',
                                 $def->name,
+                                $this->wrap('implements ', $this->join($def->interfaces, ' & ')),
                                 $this->join($def->directives, ' '),
                                 $this->block($def->fields),
                             ],

src/Language/Visitor.php

@@ -151,15 +151,15 @@ class Visitor
         NodeKind::OBJECT_TYPE_DEFINITION       => ['description', 'name', 'interfaces', 'directives', 'fields'],
         NodeKind::FIELD_DEFINITION             => ['description', 'name', 'arguments', 'type', 'directives'],
         NodeKind::INPUT_VALUE_DEFINITION       => ['description', 'name', 'type', 'defaultValue', 'directives'],
-        NodeKind::INTERFACE_TYPE_DEFINITION    => ['description', 'name', 'directives', 'fields'],
+        NodeKind::INTERFACE_TYPE_DEFINITION    => ['description', 'name', 'interfaces', 'directives', 'fields'],
         NodeKind::UNION_TYPE_DEFINITION        => ['description', 'name', 'directives', 'types'],
         NodeKind::ENUM_TYPE_DEFINITION         => ['description', 'name', 'directives', 'values'],
         NodeKind::ENUM_VALUE_DEFINITION        => ['description', 'name', 'directives'],
         NodeKind::INPUT_OBJECT_TYPE_DEFINITION => ['description', 'name', 'directives', 'fields'],
 
         NodeKind::SCALAR_TYPE_EXTENSION       => ['name', 'directives'],
         NodeKind::OBJECT_TYPE_EXTENSION       => ['name', 'interfaces', 'directives', 'fields'],
-        NodeKind::INTERFACE_TYPE_EXTENSION    => ['name', 'directives', 'fields'],
+        NodeKind::INTERFACE_TYPE_EXTENSION    => ['name', 'interfaces', 'directives', 'fields'],
         NodeKind::UNION_TYPE_EXTENSION        => ['name', 'directives', 'types'],
         NodeKind::ENUM_TYPE_EXTENSION         => ['name', 'directives', 'values'],
         NodeKind::INPUT_OBJECT_TYPE_EXTENSION => ['name', 'directives', 'fields'],

src/Type/Definition/ImplementingType.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Type\Definition;
+
+/*
+export type GraphQLImplementingType =
+GraphQLObjectType |
+GraphQLInterfaceType;
+*/
+
+interface ImplementingType
+{
+    public function implementsInterface(InterfaceType $interfaceType) : bool;
+
+    /**
+     * @return InterfaceType[]
+     */
+    public function getInterfaces() : array;
+}

src/Type/Definition/InterfaceType.php

@@ -7,12 +7,15 @@
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
 use GraphQL\Language\AST\InterfaceTypeExtensionNode;
+use GraphQL\Type\Schema;
 use GraphQL\Utils\Utils;
+use function array_map;
+use function is_array;
 use function is_callable;
 use function is_string;
 use function sprintf;
 
-class InterfaceType extends Type implements AbstractType, OutputType, CompositeType, NullableType, NamedType
+class InterfaceType extends Type implements AbstractType, OutputType, CompositeType, NullableType, NamedType, ImplementingType
 {
     /** @var InterfaceTypeDefinitionNode|null */
     public $astNode;
@@ -27,6 +30,20 @@ class InterfaceType extends Type implements AbstractType, OutputType, CompositeT
      */
     private $fields;
 
+    /**
+     * Lazily initialized.
+     *
+     * @var InterfaceType[]
+     */
+    private $interfaces;
+
+    /**
+     * Lazily initialized.
+     *
+     * @var InterfaceType[]
+     */
+    private $interfaceMap;
+
     /**
      * @param mixed[] $config
      */
@@ -99,6 +116,46 @@ protected function initializeFields() : void
         $this->fields = FieldDefinition::defineFieldMap($this, $fields);
     }
 
+    public function implementsInterface(InterfaceType $interfaceType) : bool
+    {
+        if (! isset($this->interfaceMap)) {
+            $this->interfaceMap = [];
+            foreach ($this->getInterfaces() as $interface) {
+                /** @var Type&InterfaceType $interface */
+                $interface                            = Schema::resolveType($interface);
+                $this->interfaceMap[$interface->name] = $interface;
+            }
+        }
+
+        return isset($this->interfaceMap[$interfaceType->name]);
+    }
+
+    /**
+     * @return InterfaceType[]
+     */
+    public function getInterfaces() : array
+    {
+        if (! isset($this->interfaces)) {
+            $interfaces = $this->config['interfaces'] ?? [];
+            if (is_callable($interfaces)) {
+                $interfaces = $interfaces();
+            }
+
+            if ($interfaces !== null && ! is_array($interfaces)) {
+                throw new InvariantViolation(
+                    sprintf('%s interfaces must be an Array or a callable which returns an Array.', $this->name)
+                );
+            }
+
+            /** @var InterfaceType[] $interfaces */
+            $interfaces = array_map([Schema::class, 'resolveType'], $interfaces ?? []);
+
+            $this->interfaces = $interfaces;
+        }
+
+        return $this->interfaces;
+    }
+
     /**
      * Resolves concrete ObjectType for given object value
      *

src/Type/Definition/ObjectType.php

@@ -55,7 +55,7 @@
  *        }
  *     ]);
  */
-class ObjectType extends Type implements OutputType, CompositeType, NullableType, NamedType
+class ObjectType extends Type implements OutputType, CompositeType, NullableType, NamedType, ImplementingType
 {
     /** @var ObjectTypeDefinitionNode|null */
     public $astNode;

src/Type/Introspection.php

@@ -359,7 +359,7 @@ static function (FieldDefinition $field) : bool {
                         'interfaces'    => [
                             'type'    => Type::listOf(Type::nonNull(self::_type())),
                             'resolve' => static function ($type) : ?array {
-                                if ($type instanceof ObjectType) {
+                                if ($type instanceof ObjectType || $type instanceof InterfaceType) {
                                     return $type->getInterfaces();
                                 }
 

src/Type/Schema.php

@@ -12,6 +12,7 @@
 use GraphQL\Language\AST\SchemaTypeExtensionNode;
 use GraphQL\Type\Definition\AbstractType;
 use GraphQL\Type\Definition\Directive;
+use GraphQL\Type\Definition\ImplementingType;
 use GraphQL\Type\Definition\InterfaceType;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\Type;
@@ -454,7 +455,7 @@ private function getPossibleTypeMap() : array
      *
      * @api
      */
-    public function isPossibleType(AbstractType $abstractType, ObjectType $possibleType) : bool
+    public function isPossibleType(AbstractType $abstractType, ImplementingType $possibleType) : bool
     {
         if ($abstractType instanceof InterfaceType) {
             return $possibleType->implementsInterface($abstractType);