feature: Adds UniqueOperationNamesRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/UniqueOperationNamesRule.swift

@@ -0,0 +1,30 @@
+
+/**
+ * Unique operation names
+ *
+ * A GraphQL document is only valid if all defined operations have unique names.
+ *
+ * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness
+ */
+func UniqueOperationNamesRule(context: ValidationContext) -> Visitor {
+    var knownOperationNames = [String: Name]()
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if let operation = node as? OperationDefinition {
+                if let operationName = operation.name {
+                    if let knownOperationName = knownOperationNames[operationName.value] {
+                        context.report(
+                            error: GraphQLError(
+                                message: "There can be only one operation named \"\(operationName.value)\".",
+                                nodes: [knownOperationName, operationName]
+                            )
+                        )
+                    } else {
+                        knownOperationNames[operationName.value] = operationName
+                    }
+                }
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

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

Tests/GraphQLTests/ValidationTests/UniqueOperationNamesRuleTests.swift

@@ -0,0 +1,152 @@
+@testable import GraphQL
+import XCTest
+
+class UniqueOperationNamesRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = UniqueOperationNamesRule
+    }
+
+    func testNoOperations() throws {
+        try assertValid(
+            """
+            fragment fragA on Type {
+              field
+            }
+            """
+        )
+    }
+
+    func testOneAnonOperation() throws {
+        try assertValid(
+            """
+            {
+              field
+            }
+            """
+        )
+    }
+
+    func testOneNamedOperation() throws {
+        try assertValid(
+            """
+            query Foo {
+              field
+            }
+            """
+        )
+    }
+
+    func testMultipleOperations() throws {
+        try assertValid(
+            """
+            query Foo {
+              field
+            }
+
+            query Bar {
+              field
+            }
+            """
+        )
+    }
+
+    func testMultipleOperationsOfDifferentTypes() throws {
+        try assertValid(
+            """
+            query Foo {
+              field
+            }
+
+            mutation Bar {
+              field
+            }
+
+            subscription Baz {
+              field
+            }
+            """
+        )
+    }
+
+    func testFragmentAndOperationNamedTheSame() throws {
+        try assertValid(
+            """
+            query Foo {
+              ...Foo
+            }
+            fragment Foo on Type {
+              field
+            }
+            """
+        )
+    }
+
+    func testMultipleOperationsOfSameName() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            query Foo {
+              fieldA
+            }
+            query Foo {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 1, column: 7),
+                (line: 4, column: 7),
+            ],
+            message: "There can be only one operation named \"Foo\"."
+        )
+    }
+
+    func testMultipleOperationsOfDifferentTypesMutation() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            query Foo {
+              fieldA
+            }
+            mutation Foo {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 1, column: 7),
+                (line: 4, column: 10),
+            ],
+            message: "There can be only one operation named \"Foo\"."
+        )
+    }
+
+    func testMultipleOperationsOfDifferentTypesSubscription() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            query Foo {
+              fieldA
+            }
+            subscription Foo {
+              fieldB
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 1, column: 7),
+                (line: 4, column: 14),
+            ],
+            message: "There can be only one operation named \"Foo\"."
+        )
+    }
+}