fix: Scalar parsing defaults match and reject objects correctly

Author: NeedleInAJayStack

Sources/GraphQL/Type/Definition.swift

@@ -171,35 +171,22 @@ public final class GraphQLScalarType {
     public let kind: TypeKind = .scalar
 
     let serialize: (Any) throws -> Map
-    let parseValue: ((Map) throws -> Map)?
-    let parseLiteral: ((Value) throws -> Map)?
-
-    public init(
-        name: String,
-        description: String? = nil,
-        serialize: @escaping (Any) throws -> Map
-    ) throws {
-        try assertValid(name: name)
-        self.name = name
-        self.description = description
-        self.serialize = serialize
-        parseValue = nil
-        parseLiteral = nil
-    }
+    let parseValue: (Map) throws -> Map
+    let parseLiteral: (Value) throws -> Map
 
     public init(
         name: String,
         description: String? = nil,
         serialize: @escaping (Any) throws -> Map,
-        parseValue: @escaping (Map) throws -> Map,
-        parseLiteral: @escaping (Value) throws -> Map
+        parseValue: ((Map) throws -> Map)? = nil,
+        parseLiteral: ((Value) throws -> Map)? = nil
     ) throws {
         try assertValid(name: name)
         self.name = name
         self.description = description
         self.serialize = serialize
-        self.parseValue = parseValue
-        self.parseLiteral = parseLiteral
+        self.parseValue = parseValue ?? defaultParseValue
+        self.parseLiteral = parseLiteral ?? defaultParseLiteral
     }
 
     // Serializes an internal value to include in a response.
@@ -209,15 +196,23 @@ public final class GraphQLScalarType {
 
     // Parses an externally provided value to use as an input.
     public func parseValue(value: Map) throws -> Map {
-        return try parseValue?(value) ?? Map.null
+        return try parseValue(value)
     }
 
     // Parses an externally provided literal value to use as an input.
     public func parseLiteral(valueAST: Value) throws -> Map {
-        return try parseLiteral?(valueAST) ?? Map.null
+        return try parseLiteral(valueAST)
     }
 }
 
+let defaultParseValue: ((Map) throws -> Map) = { value in
+    value
+}
+
+let defaultParseLiteral: ((Value) throws -> Map) = { value in
+    try valueFromASTUntyped(valueAST: value)
+}
+
 extension GraphQLScalarType: Encodable {
     private enum CodingKeys: String, CodingKey {
         case name

Sources/GraphQL/Utilities/ValueFromASTUntyped.swift

@@ -0,0 +1,67 @@
+import OrderedCollections
+
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * Unlike `valueFromAST()`, no type is provided. The resulting map
+ * will reflect the provided GraphQL value AST.
+ *
+ * | GraphQL Value        | Map Value |
+ * | -------------------- | ---------------- |
+ * | Input Object         | .dictionary           |
+ * | List                 | .array            |
+ * | Boolean              | .boolean          |
+ * | String / Enum        | .string           |
+ * | Int                  | .int          |
+ * | Float                | .float        |
+ * | Null                 | .null             |
+ *
+ */
+public func valueFromASTUntyped(
+    valueAST: Value,
+    variables: [String: Map] = [:]
+) throws -> Map {
+    switch valueAST {
+    case _ as NullValue:
+        return .null
+    case let value as IntValue:
+        guard let int = Int(value.value) else {
+            throw GraphQLError(message: "Int cannot represent non-integer value: \(value)")
+        }
+        return .int(int)
+    case let value as FloatValue:
+        guard let double = Double(value.value) else {
+            throw GraphQLError(message: "Float cannot represent non numeric value: \(value)")
+        }
+        return .double(double)
+    case let value as StringValue:
+        return .string(value.value)
+    case let value as EnumValue:
+        return .string(value.value)
+    case let value as BooleanValue:
+        return .bool(value.value)
+    case let value as ListValue:
+        let array = try value.values.map { try valueFromASTUntyped(
+            valueAST: $0,
+            variables: variables
+        ) }
+        return .array(array)
+    case let value as ObjectValue:
+        var dictionary = OrderedDictionary<String, Map>()
+        try value.fields.forEach { field in
+            dictionary[field.name.value] = try valueFromASTUntyped(
+                valueAST: field.value,
+                variables: variables
+            )
+        }
+        return .dictionary(dictionary)
+    case let value as Variable:
+        if let variable = variables[value.name.value] {
+            return variable
+        } else {
+            return .undefined
+        }
+    default:
+        return .undefined
+    }
+}