feature: Adds KnownTypeNamesRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/KnownTypeNamesRule.swift

@@ -0,0 +1,52 @@
+
+/**
+ * Known type names
+ *
+ * A GraphQL document is only valid if referenced types (specifically
+ * variable definitions and fragment conditions) are defined by the type schema.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ */
+func KnownTypeNamesRule(context: ValidationContext) -> Visitor {
+    let definitions = context.ast.definitions
+    let existingTypesMap = context.schema.typeMap
+
+    var typeNames = Set<String>()
+    for typeName in existingTypesMap.keys {
+        typeNames.insert(typeName)
+    }
+    for definition in definitions {
+        if
+            let type = definition as? TypeDefinition,
+            let nameResult = type.get(key: "name"),
+            case let .node(nameNode) = nameResult,
+            let name = nameNode as? Name
+        {
+            typeNames.insert(name.value)
+        }
+    }
+
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if let type = node as? NamedType {
+                let typeName = type.name.value
+                if !typeNames.contains(typeName) {
+                    // TODO: Add SDL support
+
+                    let suggestedTypes = suggestionList(
+                        input: typeName,
+                        options: Array(typeNames)
+                    )
+                    context.report(
+                        error: GraphQLError(
+                            message: "Unknown type \"\(typeName)\"." +
+                                didYouMean(suggestions: suggestedTypes),
+                            nodes: [node]
+                        )
+                    )
+                }
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -6,7 +6,7 @@ public let specifiedRules: [(ValidationContext) -> Visitor] = [
     UniqueOperationNamesRule,
     LoneAnonymousOperationRule,
 //    SingleFieldSubscriptionsRule,
-//    KnownTypeNamesRule,
+    KnownTypeNamesRule,
 //    FragmentsOnCompositeTypesRule,
 //    VariablesAreInputTypesRule,
     ScalarLeafsRule,

Tests/GraphQLTests/ValidationTests/KnownTypeNamesRuleTests.swift

@@ -0,0 +1,61 @@
+@testable import GraphQL
+import XCTest
+
+class KnownTypeNamesRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = KnownTypeNamesRule
+    }
+
+    func testKnownTypeNamesAreValid() throws {
+        try assertValid(
+            """
+            query Foo(
+              $var: String
+              $required: [Int!]!
+              $introspectionType: __EnumValue
+            ) {
+              user(id: 4) {
+                pets { ... on Pet { name }, ...PetFields, ... { name } }
+              }
+            }
+
+            fragment PetFields on Pet {
+              name
+            }
+            """
+        )
+    }
+
+    func testUnknownTypeNamesAreInvalid() throws {
+        let errors = try assertInvalid(
+            errorCount: 3,
+            query:
+            """
+            query Foo($var: [JumbledUpLetters!]!) {
+              user(id: 4) {
+                name
+                pets { ... on Badger { name }, ...PetFields }
+              }
+            }
+            fragment PetFields on Peat {
+              name
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 18)],
+            message: "Unknown type \"JumbledUpLetters\"."
+        )
+        try assertValidationError(
+            error: errors[1],
+            locations: [(line: 4, column: 19)],
+            message: "Unknown type \"Badger\"."
+        )
+        try assertValidationError(
+            error: errors[2],
+            locations: [(line: 7, column: 23)],
+            message: "Unknown type \"Peat\". Did you mean \"Pet\" or \"Cat\"?"
+        )
+    }
+}