feature: Implements oneOf directive

Author: NeedleInAJayStack

Sources/GraphQL/Type/Definition.swift

@@ -1217,12 +1217,14 @@ public final class GraphQLInputObjectType {
     public let name: String
     public let description: String?
     public let fields: InputObjectFieldDefinitionMap
+    public let isOneOf: Bool
     public let kind: TypeKind = .inputObject
 
     public init(
         name: String,
         description: String? = nil,
-        fields: InputObjectFieldMap = [:]
+        fields: InputObjectFieldMap = [:],
+        isOneOf: Bool = false
     ) throws {
         try assertValid(name: name)
         self.name = name
@@ -1231,6 +1233,7 @@ public final class GraphQLInputObjectType {
             name: name,
             fields: fields
         )
+        self.isOneOf = isOneOf
     }
 
     func replaceTypeReferences(typeMap: TypeMap) throws {
@@ -1245,6 +1248,7 @@ extension GraphQLInputObjectType: Encodable {
         case name
         case description
         case fields
+        case isOneOf
         case kind
     }
 }
@@ -1258,6 +1262,8 @@ extension GraphQLInputObjectType: KeySubscriptable {
             return description
         case CodingKeys.fields.rawValue:
             return fields
+        case CodingKeys.isOneOf.rawValue:
+            return isOneOf
         case CodingKeys.kind.rawValue:
             return kind
         default:

Sources/GraphQL/Type/Directives.swift

@@ -123,11 +123,22 @@ public let GraphQLDeprecatedDirective = try! GraphQLDirective(
     ]
 )
 
+/**
+ * Used to indicate an Input Object is a OneOf Input Object.
+ */
+public let GraphQLOneOfDirective = try! GraphQLDirective(
+    name: "oneOf",
+    description: "Indicates exactly one field must be supplied and this field must not be `null`.",
+    locations: [.inputObject],
+    args: [:]
+)
+
 /**
  * The full list of specified directives.
  */
 let specifiedDirectives: [GraphQLDirective] = [
     GraphQLIncludeDirective,
     GraphQLSkipDirective,
     GraphQLDeprecatedDirective,
+    GraphQLOneOfDirective,
 ]

Sources/GraphQL/Type/Introspection.swift

@@ -310,6 +310,15 @@ let __Type: GraphQLObjectType = try! GraphQLObjectType(
             }
         ),
         "ofType": GraphQLField(type: GraphQLTypeReference("__Type")),
+        "isOneOf": GraphQLField(
+            type: GraphQLBoolean,
+            resolve: { type, _, _, _ in
+                if let type = type as? GraphQLInputObjectType {
+                    return type.isOneOf
+                }
+                return false
+            }
+        ),
     ]
 )
 

Sources/GraphQL/Utilities/IsValidValue.swift

@@ -63,6 +63,22 @@ func validate(value: Map, forType type: GraphQLInputType) throws -> [String] {
             }
         }
 
+        // Ensure only one field in oneOf input is defined
+        if objectType.isOneOf {
+            let keys = dictionary.filter { $1 != .undefined }.keys
+            if keys.count != 1 {
+                errors.append(
+                    "Exactly one key must be specified for OneOf type \"\(objectType.name)\"."
+                )
+            }
+
+            let key = keys[0]
+            let value = dictionary[key]
+            if value == .null {
+                errors.append("Field \"\(key)\" must be non-null.")
+            }
+        }
+
         // Ensure every defined field is valid.
         for (fieldName, field) in fields {
             let newErrors = try validate(value: value[fieldName], forType: field.type).map {

Sources/GraphQL/Utilities/ValueFromAST.swift

@@ -99,6 +99,18 @@ func valueFromAST(
                 }
             }
         }
+
+        if objectType.isOneOf {
+            let keys = object.filter { $1 != .undefined }.keys
+            if keys.count != 1 {
+                return .undefined // Invalid: not exactly one key, intentionally return no value.
+            }
+
+            if object[keys[0]] == .null {
+                return .undefined // Invalid: value not non-null, intentionally return no value.
+            }
+        }
+
         return .dictionary(object)
     }
 

Sources/GraphQL/Validation/Rules/ValuesOfCorrectTypeRule.swift

@@ -37,8 +37,9 @@ func ValuesOfCorrectTypeRule(context: ValidationContext) -> Visitor {
                     return .break // Don't traverse further.
                 }
                 // Ensure every required field exists.
-                let fieldNodeMap = Dictionary(grouping: object.fields) { field in
-                    field.name.value
+                var fieldNodeMap = [String: ObjectField]()
+                for field in object.fields {
+                    fieldNodeMap[field.name.value] = field
                 }
                 for (fieldName, fieldDef) in type.fields {
                     if fieldNodeMap[fieldName] == nil, isRequiredInputField(fieldDef) {
@@ -52,7 +53,15 @@ func ValuesOfCorrectTypeRule(context: ValidationContext) -> Visitor {
                     }
                 }
 
-                // TODO: Add oneOf support
+                if type.isOneOf {
+                    validateOneOfInputObject(
+                        context: context,
+                        node: object,
+                        type: type,
+                        fieldNodeMap: fieldNodeMap,
+                        variableDefinitions: variableDefinitions
+                    )
+                }
                 return .continue
             }
             if let field = node as? ObjectField {
@@ -172,3 +181,55 @@ func isValidValueNode(_ context: ValidationContext, _ node: Value) {
         }
     }
 }
+
+func validateOneOfInputObject(
+    context: ValidationContext,
+    node: ObjectValue,
+    type: GraphQLInputObjectType,
+    fieldNodeMap: [String: ObjectField],
+    variableDefinitions: [String: VariableDefinition]
+) {
+    let keys = Array(fieldNodeMap.keys)
+    let isNotExactlyOneField = keys.count != 1
+
+    if isNotExactlyOneField {
+        context.report(
+            error: GraphQLError(
+                message: "OneOf Input Object \"\(type.name)\" must specify exactly one key.",
+                nodes: [node]
+            )
+        )
+        return
+    }
+
+    let value = fieldNodeMap[keys[0]]?.value
+    let isNullLiteral = value == nil || value?.kind == .nullValue
+
+    if isNullLiteral {
+        context.report(
+            error: GraphQLError(
+                message: "Field \"\(type.name).\(keys[0])\" must be non-null.",
+                nodes: [node]
+            )
+        )
+        return
+    }
+
+    if let value = value, value.kind == .variable {
+        let variable = value as! Variable // Force unwrap is safe because of variable definition
+        let variableName = variable.name.value
+
+        if
+            let definition = variableDefinitions[variableName],
+            definition.type.kind != .nonNullType
+        {
+            context.report(
+                error: GraphQLError(
+                    message: "Variable \"\(variableName)\" must be non-nullable to be used for OneOf Input Object \"\(type.name)\".",
+                    nodes: [node]
+                )
+            )
+            return
+        }
+    }
+}