Merge pull request #144 from NeedleInAJayStack/feature/new-directives

NeedleInAJayStack · web-flow · commit 87649dbc3cda · 2024-06-09T15:12:43.000-05:00
Adds `oneOf` and `specifiedBy` directives
diff --git a/Sources/GraphQL/Type/Definition.swift b/Sources/GraphQL/Type/Definition.swift
@@ -169,6 +169,7 @@ extension GraphQLNonNull: GraphQLWrapperType {}
 public final class GraphQLScalarType {
     public let name: String
     public let description: String?
+    public let specifiedByURL: String?
     public let kind: TypeKind = .scalar
 
     let serialize: (Any) throws -> Map
@@ -178,13 +179,15 @@ public final class GraphQLScalarType {
     public init(
         name: String,
         description: String? = nil,
+        specifiedByURL: String? = nil,
         serialize: @escaping (Any) throws -> Map,
         parseValue: ((Map) throws -> Map)? = nil,
         parseLiteral: ((Value) throws -> Map)? = nil
     ) throws {
         try assertValid(name: name)
         self.name = name
         self.description = description
+        self.specifiedByURL = specifiedByURL
         self.serialize = serialize
         self.parseValue = parseValue ?? defaultParseValue
         self.parseLiteral = parseLiteral ?? defaultParseLiteral
@@ -218,6 +221,7 @@ extension GraphQLScalarType: Encodable {
     private enum CodingKeys: String, CodingKey {
         case name
         case description
+        case specifiedByURL
         case kind
     }
 }
@@ -229,6 +233,8 @@ extension GraphQLScalarType: KeySubscriptable {
             return name
         case CodingKeys.description.rawValue:
             return description
+        case CodingKeys.specifiedByURL.rawValue:
+            return specifiedByURL
         case CodingKeys.kind.rawValue:
             return kind
         default:
@@ -1217,12 +1223,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 +1239,7 @@ public final class GraphQLInputObjectType {
             name: name,
             fields: fields
         )
+        self.isOneOf = isOneOf
     }
 
     func replaceTypeReferences(typeMap: TypeMap) throws {
@@ -1245,6 +1254,7 @@ extension GraphQLInputObjectType: Encodable {
         case name
         case description
         case fields
+        case isOneOf
         case kind
     }
 }
@@ -1258,6 +1268,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:
diff --git a/Sources/GraphQL/Type/Directives.swift b/Sources/GraphQL/Type/Directives.swift
@@ -123,11 +123,38 @@ public let GraphQLDeprecatedDirective = try! GraphQLDirective(
     ]
 )
 
+/**
+ * Used to provide a URL for specifying the behavior of custom scalar definitions.
+ */
+public let GraphQLSpecifiedByDirective = try! GraphQLDirective(
+    name: "specifiedBy",
+    description: "Exposes a URL that specifies the behavior of this scalar.",
+    locations: [.scalar],
+    args: [
+        "url": GraphQLArgument(
+            type: GraphQLNonNull(GraphQLString),
+            description: "The URL that specifies the behavior of this scalar."
+        ),
+    ]
+)
+
+/**
+ * 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,
+    GraphQLSpecifiedByDirective,
+    GraphQLOneOfDirective,
 ]
diff --git a/Sources/GraphQL/Type/Introspection.swift b/Sources/GraphQL/Type/Introspection.swift
@@ -185,7 +185,7 @@ let __Type: GraphQLObjectType = try! GraphQLObjectType(
         "many kinds of types in GraphQL as represented by the `__TypeKind` enum." +
         "\n\nDepending on the kind of a type, certain fields describe " +
         "information about that type. Scalar types provide no information " +
-        "beyond a name and description, while Enum types provide their values. " +
+        "beyond a name and description and optional `specifiedByURL`, while Enum types provide their values. " +
         "Object and Interface types provide the fields they describe. Abstract " +
         "types, Union and Interface, provide the Object types possible " +
         "at runtime. List and NonNull types compose other types.",
@@ -217,6 +217,7 @@ let __Type: GraphQLObjectType = try! GraphQLObjectType(
         ),
         "name": GraphQLField(type: GraphQLString),
         "description": GraphQLField(type: GraphQLString),
+        "specifiedByURL": GraphQLField(type: GraphQLString),
         "fields": GraphQLField(
             type: GraphQLList(GraphQLNonNull(__Field)),
             args: [
@@ -310,6 +311,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
+            }
+        ),
     ]
 )
 
diff --git a/Sources/GraphQL/Utilities/IsValidValue.swift b/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 {
diff --git a/Sources/GraphQL/Utilities/ValueFromAST.swift b/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)
     }
 
diff --git a/Sources/GraphQL/Validation/Rules/ValuesOfCorrectTypeRule.swift b/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
+        }
+    }
+}
diff --git a/Tests/GraphQLTests/ExecutionTests/OneOfTests.swift b/Tests/GraphQLTests/ExecutionTests/OneOfTests.swift
diff --git a/Tests/GraphQLTests/ValidationTests/ExampleSchema.swift b/Tests/GraphQLTests/ValidationTests/ExampleSchema.swift
diff --git a/Tests/GraphQLTests/ValidationTests/ValuesOfCorrectTypeRuleTests.swift b/Tests/GraphQLTests/ValidationTests/ValuesOfCorrectTypeRuleTests.swift

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,18 @@ func valueFromAST(`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`	`}`
	`102`	`+`
	`103`	`+ if objectType.isOneOf {`
	`104`	`+ let keys = object.filter { $1 != .undefined }.keys`
	`105`	`+ if keys.count != 1 {`
	`106`	`+ return .undefined // Invalid: not exactly one key, intentionally return no value.`
	`107`	`+ }`
	`108`	`+`
	`109`	`+ if object[keys[0]] == .null {`
	`110`	`+ return .undefined // Invalid: value not non-null, intentionally return no value.`
	`111`	`+ }`
	`112`	`+ }`
	`113`	`+`
`102`	`114`	`return .dictionary(object)`
`103`	`115`	`}`
`104`	`116`