feature: ExecutableDefinitionsRule

Author: NeedleInAJayStack

Sources/GraphQL/Language/AST.swift

@@ -1769,7 +1769,10 @@ extension OperationTypeDefinition: Equatable {
     }
 }
 
-public protocol TypeDefinition: TypeSystemDefinition {}
+public protocol TypeDefinition: TypeSystemDefinition {
+    var name: Name { get }
+}
+
 extension ScalarTypeDefinition: TypeDefinition {}
 extension ObjectTypeDefinition: TypeDefinition {}
 extension InterfaceTypeDefinition: TypeDefinition {}

Sources/GraphQL/Validation/Rules/ExecutableDefinitionsRule.swift

@@ -0,0 +1,57 @@
+
+/**
+ * Executable definitions
+ *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
+ *
+ * See https://spec.graphql.org/draft/#sec-Executable-Definitions
+ */
+func ExecutableDefinitionsRule(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 node = node as? Document {
+                for definition in node.definitions {
+                    if !isExecutable(definition) {
+                        var defName = "schema"
+                        if let definition = definition as? TypeDefinition {
+                            defName = "\"\(definition.name.value)\""
+                        } else if let definition = definition as? TypeExtensionDefinition {
+                            defName = "\"\(definition.definition.name.value)\""
+                        }
+                        context.report(
+                            error: GraphQLError(
+                                message: "The \(defName) definition is not executable.",
+                                nodes: [definition]
+                            )
+                        )
+                    }
+                }
+            }
+            return .continue
+        }
+    )
+}
+
+func isExecutable(_ definition: Definition) -> Bool {
+    definition.kind == .operationDefinition || definition
+        .kind == .fragmentDefinition
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -2,7 +2,7 @@
  * This set includes all validation rules defined by the GraphQL spec.
  */
 public let specifiedRules: [(ValidationContext) -> Visitor] = [
-//   ExecutableDefinitionsRule,
+    ExecutableDefinitionsRule,
     UniqueOperationNamesRule,
     LoneAnonymousOperationRule,
 //    SingleFieldSubscriptionsRule,

Tests/GraphQLTests/ValidationTests/ExecutableDefinitionsRuleTests.swift

@@ -0,0 +1,102 @@
+@testable import GraphQL
+import XCTest
+
+class ExecutableDefinitionsRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = ExecutableDefinitionsRule
+    }
+
+    func testWithOnlyOperation() throws {
+        try assertValid(
+            """
+            query Foo {
+              dog {
+                name
+              }
+            }
+            """
+        )
+    }
+
+    func testWithOperationAndFragment() throws {
+        try assertValid(
+            """
+            query Foo {
+              dog {
+                name
+                ...Frag
+              }
+            }
+
+            fragment Frag on Dog {
+              name
+            }
+            """
+        )
+    }
+
+    func testWithTypeDefinition() throws {
+        let errors = try assertInvalid(
+            errorCount: 2,
+            query: """
+            query Foo {
+              dog {
+                name
+              }
+            }
+
+            type Cow {
+              name: String
+            }
+
+            extend type Dog {
+              color: String
+            }
+            """
+        )
+
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 7, column: 1)],
+            message: #"The "Cow" definition is not executable."#
+        )
+        try assertValidationError(
+            error: errors[1],
+            locations: [(line: 11, column: 1)],
+            message: #"The "Dog" definition is not executable."#
+        )
+    }
+
+    func testWithSchemaDefinition() throws {
+        let errors = try assertInvalid(
+            errorCount: 3,
+            query: """
+            schema {
+              query: Query
+            }
+
+            type Query {
+              test: String
+            }
+
+            extend schema @directive
+            """
+        )
+
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 1)],
+            message: #"The schema definition is not executable."#
+        )
+        try assertValidationError(
+            error: errors[1],
+            locations: [(line: 5, column: 1)],
+            message: #"The "Query" definition is not executable."#
+        )
+        try assertValidationError(
+            error: errors[2],
+            locations: [(line: 9, column: 1)],
+            message: #"The schema definition is not executable."#
+        )
+    }
+}