Added some more validators.

Author: paulofaria

Sources/GraphQL/Execution/Execute.swift

@@ -638,7 +638,10 @@ func doesFragmentConditionMatch(
     }
 
     if let abstractType = conditionalType as? GraphQLAbstractType {
-        return try exeContext.schema.isPossibleType(abstractType: abstractType, possibleType: type)
+        return exeContext.schema.isSubType(
+            abstractType: abstractType,
+            maybeSubType: type
+        )
     }
 
     return false
@@ -1062,7 +1065,7 @@ func completeAbstractValue(
         )
     }
 
-    if try !exeContext.schema.isPossibleType(abstractType: returnType, possibleType: objectType) {
+    if !exeContext.schema.isSubType(abstractType: returnType, maybeSubType: objectType) {
         throw GraphQLError(
             message:
             "Runtime Object type \"\(objectType.name)\" is not a possible type " +

Sources/GraphQL/Language/AST.swift

@@ -1272,12 +1272,20 @@ public final class InterfaceTypeDefinition {
     public let kind: Kind = .interfaceTypeDefinition
     public let loc: Location?
     public let name: Name
+    public let interfaces: [NamedType]
     public let directives: [Directive]
     public let fields: [FieldDefinition]
 
-    init(loc: Location? = nil, name: Name, directives: [Directive] = [], fields: [FieldDefinition]) {
+    init(
+        loc: Location? = nil,
+        name: Name,
+        interfaces: [NamedType] = [],
+        directives: [Directive] = [],
+        fields: [FieldDefinition]
+    ) {
         self.loc = loc
         self.name = name
+        self.interfaces = interfaces
         self.directives = directives
         self.fields = fields
     }

Sources/GraphQL/Language/Parser.swift

@@ -803,10 +803,11 @@ func parseInputValueDef(lexer: Lexer) throws -> InputValueDefinition {
  * InterfaceTypeDefinition : interface Name Directives? { FieldDefinition+ }
  */
 func parseInterfaceTypeDefinition(lexer: Lexer) throws -> InterfaceTypeDefinition {
-    let start = lexer.token;
-    try expectKeyword(lexer: lexer, value: "interface");
-    let name = try parseName(lexer: lexer);
-    let directives = try parseDirectives(lexer: lexer);
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "interface")
+    let name = try parseName(lexer: lexer)
+    let interfaces = try parseImplementsInterfaces(lexer: lexer)
+    let directives = try parseDirectives(lexer: lexer)
     let fields = try any(
         lexer: lexer,
         openKind: .openingBrace,
@@ -816,6 +817,7 @@ func parseInterfaceTypeDefinition(lexer: Lexer) throws -> InterfaceTypeDefinitio
     return InterfaceTypeDefinition(
         loc: loc(lexer: lexer, startToken: start),
         name: name,
+        interfaces: interfaces,
         directives: directives,
         fields: fields
     )

Sources/GraphQL/Language/Visitor.swift

@@ -35,7 +35,7 @@ let QueryDocumentKeys: [Kind: [String]] = [
     .objectTypeDefinition: ["name", "interfaces", "directives", "fields"],
     .fieldDefinition: ["name", "arguments", "type", "directives"],
     .inputValueDefinition: ["name", "type", "defaultValue", "directives"],
-    .interfaceTypeDefinition: ["name", "directives", "fields"],
+    .interfaceTypeDefinition: ["name", "interfaces", "directives", "fields"],
     .unionTypeDefinition: ["name", "directives", "types"],
     .enumTypeDefinition: ["name", "directives", "values"],
     .enumValueDefinition: ["name", "directives"],

Sources/GraphQL/Type/Definition.swift

@@ -739,21 +739,26 @@ public final class GraphQLInterfaceType {
     public let description: String?
     public let resolveType: GraphQLTypeResolve?
     public let fields: GraphQLFieldDefinitionMap
+    public let interfaces: [GraphQLInterfaceType]
     public let kind: TypeKind = .interface
 
     public init(
         name: String,
         description: String? = nil,
+        interfaces: [GraphQLInterfaceType] = [],
         fields: GraphQLFieldMap,
         resolveType: GraphQLTypeResolve? = nil
     ) throws {
         try assertValid(name: name)
         self.name = name
         self.description = description
+        
         self.fields = try defineFieldMap(
             name: name,
             fields: fields
         )
+        
+        self.interfaces = interfaces
         self.resolveType = resolveType
     }
 

Sources/GraphQL/Type/Introspection.swift

@@ -253,11 +253,16 @@ let __Type: GraphQLObjectType = try! GraphQLObjectType(
         "interfaces": GraphQLField(
             type: GraphQLList(GraphQLNonNull(GraphQLTypeReference("__Type"))),
             resolve: { type, _, _, _ -> [GraphQLInterfaceType]? in
-                guard let type = type as? GraphQLObjectType else {
-                    return nil
+                if let type = type as? GraphQLObjectType {
+                    return type.interfaces
                 }
 
-                return type.interfaces
+                if let type = type as? GraphQLInterfaceType {
+                    return type.interfaces
+                }
+                
+                return nil
+                
             }
         ),
         "possibleTypes": GraphQLField(
@@ -403,7 +408,7 @@ let __TypeKind = try! GraphQLEnumType(
         "INTERFACE": GraphQLEnumValue(
             value: Map(TypeKind.interface.rawValue),
             description: "Indicates this type is an interface. " +
-            "`fields` and `possibleTypes` are valid fields."
+            "`fields`, `interfaces`, and `possibleTypes` are valid fields."
         ),
         "UNION": GraphQLEnumValue(
             value: Map(TypeKind.union.rawValue),

Sources/GraphQL/Type/Schema.swift

@@ -31,8 +31,8 @@ public final class GraphQLSchema {
     public let subscriptionType: GraphQLObjectType?
     public let directives: [GraphQLDirective]
     public let typeMap: TypeMap
-    public let implementations: [String: [GraphQLObjectType]]
-    private var possibleTypeMap: [String: [String: Bool]] = [:]
+    public let implementations: [String: InterfaceImplementations]
+    private var subTypeMap: [String: [String: Bool]] = [:]
 
     public init(
         query: GraphQLObjectType,
@@ -77,22 +77,7 @@ public final class GraphQLSchema {
         try replaceTypeReferences(typeMap: typeMap)
 
         // Keep track of all implementations by interface name.
-        var implementations: [String: [GraphQLObjectType]] = [:]
-
-        for (_, type) in typeMap {
-            if let object = type as? GraphQLObjectType {
-                for interface in object.interfaces {
-                    if var i = implementations[interface.name] {
-                        i.append(object)
-                        implementations[interface.name] = i
-                    } else {
-                        implementations[interface.name] = [object]
-                    }
-                }
-            }
-        }
-
-        self.implementations = implementations.mapValues { $0.sorted { $0.fields.count > $1.fields.count } }
+        self.implementations = collectImplementations(types: Array(typeMap.values))
 
         // Enforce correct interface implementations.
         for (_, type) in typeMap {
@@ -109,48 +94,70 @@ public final class GraphQLSchema {
     }
 
     public func getPossibleTypes(abstractType: GraphQLAbstractType) -> [GraphQLObjectType] {
-        if let union = abstractType as? GraphQLUnionType {
-            return union.types
+        if let unionType = abstractType as? GraphQLUnionType {
+            return unionType.types
         }
-
-        if let interface = abstractType as? GraphQLInterfaceType {
-            return implementations[interface.name] ?? []
+        
+        if let interfaceType = abstractType as? GraphQLInterfaceType {
+            return getImplementations(interfaceType: interfaceType).objects
         }
-
+        
         fatalError("Should be impossible. Only UnionType and InterfaceType should conform to AbstractType")
     }
+    
+    public func getImplementations(
+        interfaceType: GraphQLInterfaceType
+    ) -> InterfaceImplementations {
+        implementations[interfaceType.name]!
+    }
 
-    public func isPossibleType(abstractType: GraphQLAbstractType, possibleType: GraphQLObjectType) throws -> Bool {
-        if possibleTypeMap[abstractType.name] == nil {
-            let possibleTypes = getPossibleTypes(abstractType: abstractType)
-
-            guard !possibleTypes.isEmpty else {
-                throw GraphQLError(
-                    message:
-                    "Could not find possible implementing types for \(abstractType.name) " +
-                    "in schema. Check that schema.types is defined and is an array of " +
-                    "all possible types in the schema."
-                )
-
+    // @deprecated: use isSubType instead - will be removed in the future.
+    public func isPossibleType(
+        abstractType: GraphQLAbstractType,
+        possibleType: GraphQLObjectType
+    ) throws -> Bool {
+        isSubType(abstractType: abstractType, maybeSubType: possibleType)
+    }
+    
+    public func isSubType(
+      abstractType: GraphQLAbstractType,
+      maybeSubType: GraphQLNamedType
+    ) -> Bool {
+        var map = subTypeMap[abstractType.name]
+
+        if map == nil {
+            map = [:]
+
+            if let unionType = abstractType as? GraphQLUnionType {
+                for type in unionType.types {
+                    map?[type.name] = true
+                }
             }
-
-            var map: [String: Bool] = [:]
-
-            for type in possibleTypes {
-                map[type.name] = true
+            
+            if let interfaceType = abstractType as? GraphQLInterfaceType {
+                let implementations = getImplementations(interfaceType: interfaceType)
+                
+                for type in implementations.objects {
+                    map?[type.name] = true
+                }
+                
+                for type in implementations.interfaces {
+                    map?[type.name] = true
+                }
             }
-
-            possibleTypeMap[abstractType.name] = map
+            
+            subTypeMap[abstractType.name] = map
         }
 
-        return possibleTypeMap[abstractType.name]?[possibleType.name] != nil
+        let isSubType = map?[maybeSubType.name] != nil
+        return isSubType
     }
 
-
     public func getDirective(name: String) -> GraphQLDirective? {
         for directive in directives where directive.name == name {
             return directive
         }
+        
         return nil
     }
 }
@@ -166,6 +173,51 @@ extension GraphQLSchema : Encodable {
 
 public typealias TypeMap = [String: GraphQLNamedType]
 
+public struct InterfaceImplementations {
+    public let objects: [GraphQLObjectType]
+    public let interfaces: [GraphQLInterfaceType]
+    
+    public init(
+        objects: [GraphQLObjectType] = [],
+        interfaces: [GraphQLInterfaceType] = []
+    ) {
+        self.objects = objects
+        self.interfaces = interfaces
+    }
+}
+
+func collectImplementations(
+  types: [GraphQLNamedType]
+) -> [String : InterfaceImplementations] {
+    var implementations: [String: InterfaceImplementations] = [:]
+
+    for type in types {
+        if let type = type as? GraphQLInterfaceType {
+            if implementations[type.name] == nil {
+                implementations[type.name] = InterfaceImplementations()
+            }
+
+            // Store implementations by interface.
+            for iface in type.interfaces {
+                implementations[iface.name] = InterfaceImplementations(
+                    interfaces: (implementations[iface.name]?.interfaces ?? []) + [type]
+                )
+            }
+        }
+        
+        if let type = type as? GraphQLObjectType {
+            // Store implementations by objects.
+            for iface in type.interfaces {
+                implementations[iface.name] = InterfaceImplementations(
+                    objects: (implementations[iface.name]?.objects ?? []) + [type]
+                )
+            }
+        }
+    }
+
+    return implementations
+}
+
 func typeMapReducer(typeMap: TypeMap, type: GraphQLType) throws -> TypeMap {
     var typeMap = typeMap
 
@@ -197,9 +249,7 @@ func typeMapReducer(typeMap: TypeMap, type: GraphQLType) throws -> TypeMap {
 
     if let type = type as? GraphQLObjectType {
         typeMap = try type.interfaces.reduce(typeMap, typeMapReducer)
-    }
 
-    if let type = type as? GraphQLObjectType {
         for (_, field) in type.fields {
 
             if !field.args.isEmpty {
@@ -212,6 +262,8 @@ func typeMapReducer(typeMap: TypeMap, type: GraphQLType) throws -> TypeMap {
     }
 
     if let type = type as? GraphQLInterfaceType {
+        typeMap = try type.interfaces.reduce(typeMap, typeMapReducer)
+        
         for (_, field) in type.fields {
 
             if !field.args.isEmpty {