Fix bugs.

Author: paulofaria

Sources/GraphQL/Type/Definition.swift

@@ -1477,10 +1477,10 @@ extension GraphQLNonNull : Hashable {
 }
 
 /**
- * A special type to allow a object/interface types to reference itself. It's replaced with the real type
+ * A special type to allow object/interface types to reference itself. It's replaced with the real type
  * object when the schema is built.
  */
-public final class GraphQLTypeReference : GraphQLType, GraphQLOutputType, GraphQLNullableType {
+public final class GraphQLTypeReference : GraphQLType, GraphQLOutputType, GraphQLNullableType, GraphQLNamedType {
     public let name: String
     public let kind: TypeKind = .typeReference
 

Sources/GraphQL/Type/Directives.swift

@@ -90,7 +90,7 @@ public let GraphQLSkipDirective = try! GraphQLDirective(
 /**
  * Constant string used for default reason for a deprecation.
  */
-let defaulDeprecationReason: Map = .string("\"No longer supported\"")
+let defaulDeprecationReason: Map = "No longer supported"
 
 /**
  * Used to declare element of a GraphQL schema as deprecated.
@@ -104,8 +104,8 @@ public let GraphQLDeprecatedDirective = try! GraphQLDirective(
         .enumValue,
         ],
     args: [
-        "if": GraphQLArgument(
-            type: GraphQLNonNull(GraphQLBoolean),
+        "reason": GraphQLArgument(
+            type: GraphQLString,
             description:
             "Explains why this element was deprecated, usually also including a " +
             "suggestion for how to access supported similar data. Formatted " +

Sources/GraphQL/Type/Introspection.swift

@@ -355,8 +355,6 @@ let __InputValue = try! GraphQLObjectType(
                     return nil
                 }
 
-                // This `print` is from the AST printer implementation
-//                return print(astFromValue(value: defaultValue, type: inputValue.type))
                 return defaultValue
             }
         )

Sources/GraphQL/Type/Schema.swift

@@ -92,7 +92,7 @@ public final class GraphQLSchema {
             }
         }
 
-        self.implementations = implementations
+        self.implementations = implementations.mapValues { $0.sorted { $0.fields.count > $1.fields.count } }
 
         // Enforce correct interface implementations.
         for (_, type) in typeMap {
@@ -117,8 +117,7 @@ public final class GraphQLSchema {
             return implementations[interface.name] ?? []
         }
 
-        // Should be impossible. Only UnionType and InterfaceType should conform to AbstractType
-        return []
+        fatalError("Should be impossible. Only UnionType and InterfaceType should conform to AbstractType")
     }
 
     public func isPossibleType(abstractType: GraphQLAbstractType, possibleType: GraphQLObjectType) throws -> Bool {
@@ -178,8 +177,8 @@ func typeMapReducer(typeMap: TypeMap, type: GraphQLType) throws -> TypeMap {
         return typeMap // Should never happen
     }
 
-    guard typeMap[type.name] == nil else {
-        guard typeMap[type.name]! == type else {
+    guard typeMap[type.name] == nil || typeMap[type.name] is GraphQLTypeReference else {
+        guard typeMap[type.name]! == type || type is GraphQLTypeReference else {
             throw GraphQLError(
                 message:
                 "Schema must contain unique named types but contains multiple " +

Sources/GraphQL/Utilities/ASTFromValue.swift

@@ -30,7 +30,7 @@ func astFromValue(
         return nil
     }
 
-    // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+    // Convert array to GraphQL list. If the GraphQLType is a list, but
     // the value is not an array, convert the value using the list's item type.
     if let type = type as? GraphQLList {
         let itemType = type.ofType as! GraphQLInputType
@@ -86,7 +86,7 @@ func astFromValue(
         return nil
     }
 
-    // Others serialize based on their corresponding JavaScript scalar types.
+    // Others serialize based on their corresponding scalar types.
     if case let .number(number) = serialized {
         switch number.storageType {
         case .bool:

Sources/GraphQL/Utilities/TypeComparators.swift

@@ -55,6 +55,10 @@ func == (lhs: GraphQLType, rhs: GraphQLType) -> Bool {
         if let r = rhs as? GraphQLNonNull {
             return l == r
         }
+    case let l as GraphQLTypeReference:
+        if let r = rhs as? GraphQLTypeReference {
+            return l.name == r.name
+        }
     default:
         return false
     }

Sources/GraphQL/Validation/Rules/KnownArgumentNames.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+ func undefinedArgumentMessage(
+    fieldName: String,
+    type: String,
+    argumentName: String,
+    suggestedArgumentNames: [String]
+) -> String {
+    var message = "Field \"\(fieldName)\" on type \"\(type)\" does not have argument \"\(argumentName)\"."
+
+     if !suggestedArgumentNames.isEmpty {
+        let suggestions = quotedOrList(items: suggestedArgumentNames)
+        message += " Did you mean \(suggestions)?"
+    }
+
+     return message
+}
+
+ func KnownArgumentNames(context: ValidationContext) -> Visitor {
+    return Visitor(
+        enter: { node, key, parent, path, ancestors in
+            if let node = node as? Argument, context.argument == nil, let field = context.fieldDef, let type = context.parentType {
+                let argumentName = node.name.value
+                let suggestedArgumentNames = getSuggestedArgumentNames(schema: context.schema, field: field, argumentName: argumentName)
+
+                 context.report(error: GraphQLError(
+                    message: undefinedArgumentMessage(
+                        fieldName: field.name,
+                        type: type.name,
+                        argumentName: argumentName,
+                        suggestedArgumentNames: suggestedArgumentNames
+                    ),
+                    nodes: [node]
+                ))
+            }
+
+             return .continue
+        }
+    )
+}
+
+ func getSuggestedArgumentNames(
+    schema: GraphQLSchema,
+    field: GraphQLFieldDefinition,
+    argumentName: String
+) -> [String] {
+    return suggestionList(
+        input: argumentName,
+        options: field.args.map { $0.name }
+    )
+}

Sources/GraphQL/Validation/Rules/ProvidedNonNullArguments.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+ func missingArgumentsMessage(
+    fieldName: String,
+    type: String,
+    missingArguments: [String]
+) -> String {
+    let arguments = quotedOrList(items: missingArguments)
+    return "Field \"\(fieldName)\" on type \"\(type)\" is missing required arguments \(arguments)."
+}
+
+ func ProvidedNonNullArguments(context: ValidationContext) -> Visitor {
+    return Visitor(
+        leave: { node, key, parent, path, ancestors in
+            if let node = node as? Field, let field = context.fieldDef, let type = context.parentType {
+                let requiredArguments = Set(
+                    field
+                        .args
+                        .filter { $0.type is GraphQLNonNull && $0.defaultValue == nil }
+                        .map { $0.name }
+                )
+
+                 let providedArguments = Set(node.arguments.map { $0.name.value })
+
+                 let missingArguments = requiredArguments.subtracting(providedArguments)
+                if !missingArguments.isEmpty {
+                    context.report(error: GraphQLError(
+                        message: missingArgumentsMessage(
+                            fieldName: field.name,
+                            type: type.name,
+                            missingArguments: Array(missingArguments)
+                        ),
+                        nodes: [node]
+                    ))
+                }
+            }
+
+             return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -18,10 +18,10 @@ let specifiedRules: [(ValidationContext) -> Visitor] = [
 //    NoUndefinedVariables,
 //    NoUnusedVariables,
 //    KnownDirectives,
-//    KnownArgumentNames,
+    KnownArgumentNames,
 //    UniqueArgumentNames,
 //    ArgumentsOfCorrectType,
-//    ProvidedNonNullArguments,
+    ProvidedNonNullArguments,
 //    DefaultValuesOfCorrectType,
 //    VariablesInAllowedPosition,
 //    OverlappingFieldsCanBeMerged,

Tests/GraphQLTests/ValidationTests/KnownArgumentNamesTests.swift

@@ -0,0 +1,56 @@
+@testable import GraphQL
+import XCTest
+
+class KnownArgumentNamesTests : ValidationTestCase {
+    override func setUp() {
+        rule = KnownArgumentNames
+    }
+    
+    func testValidWithObjectWithoutArguments() throws {
+        try assertValid(
+            "fragment objectFieldSelection on Dog { __typename name }"
+        )
+    }
+    
+    func testValidWithCorrectArgumentNames() throws {
+        try assertValid(
+            "fragment objectFieldSelection on Dog { __typename isHousetrained(atOtherHomes: true) }"
+        )
+    }
+    
+    func testInvalidWithSlightlyMisspelledArgument() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query: "fragment objectFieldSelection on Dog { __typename isHousetrained(atOtherHomees: true) }"
+        )
+        
+        try assertValidationError(
+            error: errors.first, line: 1, column: 66,
+            message: #"Field "isHousetrained" on type "Dog" does not have argument "atOtherHomees". Did you mean "atOtherHomes"?"#
+        )
+    }
+    
+    func testInvalidWithUnrelatedArgument() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query: "fragment objectFieldSelection on Dog { __typename name(uppercased: true) }"
+        )
+        
+        try assertValidationError(
+            error: errors.first, line: 1, column: 56,
+            message: #"Field "name" on type "Dog" does not have argument "uppercased"."#
+        )
+    }
+    
+}
+
+extension KnownArgumentNamesTests {
+    static var allTests: [(String, (KnownArgumentNamesTests) -> () throws -> Void)] {
+        return [
+            ("testValidWithObjectWithoutArguments", testValidWithObjectWithoutArguments),
+            ("testValidWithCorrectArgumentNames", testValidWithCorrectArgumentNames),
+            ("testInvalidWithSlightlyMisspelledArgument", testInvalidWithSlightlyMisspelledArgument),
+            ("testInvalidWithUnrelatedArgument", testInvalidWithUnrelatedArgument),
+        ]
+    }
+}