feature: Adds LoneAnonymousOperationRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/LoneAnonymousOperationRule.swift

@@ -0,0 +1,32 @@
+
+/**
+ * Lone anonymous operation
+ *
+ * A GraphQL document is only valid if when it contains an anonymous operation
+ * (the query short-hand) that it contains only that one operation definition.
+ *
+ * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ */
+func LoneAnonymousOperationRule(context: ValidationContext) -> Visitor {
+    var operationCount = 0
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if let document = node as? Document {
+                operationCount = document.definitions.filter { $0 is OperationDefinition }.count
+                return .continue
+            }
+            if let operation = node as? OperationDefinition {
+                if operation.name == nil, operationCount > 1 {
+                    context.report(
+                        error: GraphQLError(
+                            message: "This anonymous operation must be the only defined operation.",
+                            nodes: [operation]
+                        )
+                    )
+                }
+                return .continue
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

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

Tests/GraphQLTests/ValidationTests/LoneAnonymousOperationRuleTests.swift

@@ -0,0 +1,120 @@
+@testable import GraphQL
+import XCTest
+
+class LoneAnonymousOperationRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = LoneAnonymousOperationRule
+    }
+
+    func testNoOperations() throws {
+        try assertValid(
+            """
+            fragment fragA on Type {
+              field
+            }
+            """
+        )
+    }
+
+    func testOneAnonOperation() throws {
+        try assertValid(
+            """
+            {
+              field
+            }
+            """
+        )
+    }
+
+    func testMultipleNamedOperations() throws {
+        try assertValid(
+            """
+            query Foo {
+              field
+            }
+
+            query Bar {
+              field
+            }
+            """
+        )
+    }
+
+    func testAnonOperationWithFragment() throws {
+        try assertValid(
+            """
+            {
+              ...Foo
+            }
+            fragment Foo on Type {
+              field
+            }
+            """
+        )
+    }
+
+    func testMultipleAnonOperations() throws {
+        let errors = try assertInvalid(
+            errorCount: 2,
+            query:
+            """
+            {
+              fieldA
+            }
+            {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 1)],
+            message: "This anonymous operation must be the only defined operation."
+        )
+        try assertValidationError(
+            error: errors[1],
+            locations: [(line: 4, column: 1)],
+            message: "This anonymous operation must be the only defined operation."
+        )
+    }
+
+    func testAnonOperationWithAMutation() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              fieldA
+            }
+            mutation Foo {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 1)],
+            message: "This anonymous operation must be the only defined operation."
+        )
+    }
+
+    func testAnonOperationWithASubscription() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              fieldA
+            }
+            subscription Foo {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 1)],
+            message: "This anonymous operation must be the only defined operation."
+        )
+    }
+}