feat: Adds oneOf input object directive

Author: NeedleInAJayStack

Package.resolved

@@ -7,7 +7,7 @@ let package = Package(
         .library(name: "Graphiti", targets: ["Graphiti"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "2.9.2"),
+        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "2.10.0"),
     ],
     targets: [
         .target(name: "Graphiti", dependencies: ["GraphQL"]),

Package.swift

@@ -8,13 +8,15 @@ public final class Input<
     Resolver,
     Context
 > {
+    let isOneOf: Bool
     let fields: [InputFieldComponent<InputObjectType, Context>]
 
     override func update(typeProvider: SchemaTypeProvider, coders _: Coders) throws {
         let inputObjectType = try GraphQLInputObjectType(
             name: name,
             description: description,
-            fields: fields(typeProvider: typeProvider)
+            fields: fields(typeProvider: typeProvider),
+            isOneOf: isOneOf
         )
 
         try typeProvider.add(type: InputObjectType.self, as: inputObjectType)
@@ -38,8 +40,10 @@ public final class Input<
     init(
         type _: InputObjectType.Type,
         name: String?,
+        isOneOf: Bool,
         fields: [InputFieldComponent<InputObjectType, Context>]
     ) {
+        self.isOneOf = isOneOf
         self.fields = fields
         super.init(
             name: name ?? Reflection.name(for: InputObjectType.self),
@@ -52,18 +56,20 @@ public extension Input {
     convenience init(
         _ type: InputObjectType.Type,
         as name: String? = nil,
+        isOneOf: Bool = false,
         @InputFieldComponentBuilder<InputObjectType, Context> _ fields: ()
             -> InputFieldComponent<InputObjectType, Context>
     ) {
-        self.init(type: type, name: name, fields: [fields()])
+        self.init(type: type, name: name, isOneOf: isOneOf, fields: [fields()])
     }
 
     convenience init(
         _ type: InputObjectType.Type,
         as name: String? = nil,
+        isOneOf: Bool = false,
         @InputFieldComponentBuilder<InputObjectType, Context> _ fields: ()
             -> [InputFieldComponent<InputObjectType, Context>]
     ) {
-        self.init(type: type, name: name, fields: fields())
+        self.init(type: type, name: name, isOneOf: isOneOf, fields: fields())
     }
 }

Sources/Graphiti/Input/Input.swift

@@ -74,4 +74,89 @@ class DirectiveTests: XCTestCase {
 
         XCTAssertEqual(response, expected)
     }
+
+    func testOneOfAcceptsGoodValue() throws {
+        try XCTAssertEqual(
+            OneOfAPI().execute(
+                request: """
+                query {
+                    test(input: {a: "abc"}) {
+                        a
+                        b
+                    }
+                }
+                """,
+                context: NoContext(),
+                on: group
+            ).wait(),
+            GraphQLResult(
+                data: [
+                    "test": [
+                        "a": "abc",
+                        "b": .null,
+                    ],
+                ]
+            )
+        )
+    }
+
+    func testOneOfRejectsBadValue() throws {
+        try XCTAssertEqual(
+            OneOfAPI().execute(
+                request: """
+                query {
+                    test(input: {a: "abc", b: 123}) {
+                        a
+                        b
+                    }
+                }
+                """,
+                context: NoContext(),
+                on: group
+            ).wait().errors[0].message,
+            #"OneOf Input Object "TestInputObject" must specify exactly one key."#
+        )
+    }
+
+    struct OneOfAPI: API {
+        struct TestObject: Codable {
+            let a: String?
+            let b: Int?
+        }
+
+        struct TestInputObject: Codable {
+            let a: String?
+            let b: Int?
+        }
+
+        struct TestArguments: Codable {
+            let input: TestInputObject
+        }
+
+        struct OneOfResolver {
+            func test(context _: NoContext, arguments: TestArguments) -> TestObject {
+                return TestObject(a: arguments.input.a, b: arguments.input.b)
+            }
+        }
+
+        let resolver = OneOfResolver()
+
+        let schema = try! Schema<OneOfResolver, NoContext> {
+            Type(TestObject.self) {
+                Field("a", at: \.a)
+                Field("b", at: \.b)
+            }
+
+            Input(TestInputObject.self, isOneOf: true) {
+                InputField("a", at: \.a)
+                InputField("b", at: \.b)
+            }
+
+            Query {
+                Field("test", at: OneOfResolver.test, as: TestObject.self) {
+                    Argument("input", at: \.input)
+                }
+            }
+        }
+    }
 }