feature: Adds UniqueInputFieldNamesRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/UniqueInputFieldNamesRule.swift

@@ -0,0 +1,45 @@
+
+/**
+ * Unique input field names
+ *
+ * A GraphQL input object value is only valid if all supplied fields are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness
+ */
+func UniqueInputFieldNamesRule(context: ValidationContext) -> Visitor {
+    var knownNameStack = [[String: Name]]()
+    var knownNames = [String: Name]()
+
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if node is ObjectValue {
+                knownNameStack.append(knownNames)
+                knownNames = [:]
+                return .continue
+            }
+            if let objectField = node as? ObjectField {
+                let fieldName = objectField.name.value
+                if let knownName = knownNames[fieldName] {
+                    context.report(
+                        error: GraphQLError(
+                            message: "There can be only one input field named \"\(fieldName)\".",
+                            nodes: [knownName, objectField.name]
+                        )
+                    )
+                } else {
+                    knownNames[fieldName] = objectField.name
+                }
+                return .continue
+            }
+            return .continue
+        },
+        leave: { node, _, _, _, _ in
+            if node is ObjectValue {
+                let prevKnownNames = knownNameStack.popLast()
+                knownNames = prevKnownNames ?? [:]
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -33,5 +33,5 @@ public let specifiedRules: [(ValidationContext) -> Visitor] = [
 //    DefaultValuesOfCorrectTypeRule,
 //    VariablesInAllowedPositionRule,
 //    OverlappingFieldsCanBeMergedRule,
-//    UniqueInputFieldNamesRule,
+    UniqueInputFieldNamesRule,
 ]

Tests/GraphQLTests/ValidationTests/UniqueInputFieldNamesRuleTests.swift

@@ -0,0 +1,124 @@
+@testable import GraphQL
+import XCTest
+
+class UniqueInputFieldNamesRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = UniqueInputFieldNamesRule
+    }
+
+    func testInputObjectWithFields() throws {
+        try assertValid(
+            """
+            {
+              field(arg: { f: true })
+            }
+            """
+        )
+    }
+
+    func testSameInputObjectWithinTwoArgs() throws {
+        try assertValid(
+            """
+            {
+              field(arg1: { f: true }, arg2: { f: true })
+            }
+            """
+        )
+    }
+
+    func testMultipleInputObjectFields() throws {
+        try assertValid(
+            """
+            {
+              field(arg: { f1: "value", f2: "value", f3: "value" })
+            }
+            """
+        )
+    }
+
+    func testAllowsForNestedInputObjectsWithSimilarFields() throws {
+        try assertValid(
+            """
+            {
+              field(arg: {
+                deep: {
+                  deep: {
+                    id: 1
+                  }
+                  id: 1
+                }
+                id: 1
+              })
+            }
+            """
+        )
+    }
+
+    func testDuplicateInputObjectFields() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field(arg: { f1: "value", f1: "value" })
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 16),
+                (line: 2, column: 29),
+            ],
+            message: #"There can be only one input field named "f1"."#
+        )
+    }
+
+    func testManyDuplicateInputObjectFields() throws {
+        let errors = try assertInvalid(
+            errorCount: 2,
+            query:
+            """
+            {
+              field(arg: { f1: "value", f1: "value", f1: "value" })
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 16),
+                (line: 2, column: 29),
+            ],
+            message: #"There can be only one input field named "f1"."#
+        )
+        try assertValidationError(
+            error: errors[1],
+            locations: [
+                (line: 2, column: 16),
+                (line: 2, column: 42),
+            ],
+            message: #"There can be only one input field named "f1"."#
+        )
+    }
+
+    func testNestedDuplicateInputObjectFields() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field(arg: { f1: {f2: "value", f2: "value" }})
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 21),
+                (line: 2, column: 34),
+            ],
+            message: #"There can be only one input field named "f2"."#
+        )
+    }
+}