         let testSchema = try Schema<TestResolver, NoContext>(
             coders: coders
         ) {
-            DateScalar(as: "Date", formatter: ISO8601DateFormatter())
+            Scalar(Date.self, as: "Date")
             Type(DateOutput.self) {
                 Field("value", at: \.value)
             }

            GraphQLResult(data: [
                "date": [
                    "value": "2001-01-01T00:00:00Z"
                ]
            ])
        )

        self.schema = schema
    }
}

struct StringCodedCoordinate : Codable {
    let latitude: Double
    let longitude: Double
    
    init(latitude: Double, longitude: Double) {
        self.latitude = latitude
        self.longitude = longitude
    }
    
    init(_ string: String) throws {
        let range = NSRange(location: 0, length: string.utf8.count)
        let regex = try NSRegularExpression(pattern: "\\((.*), (.*)\\)")
        guard let match = regex.firstMatch(in: string, options: .init(), range: range) else {
            throw GraphQLError(message: "Coordinate string didn't match expected value")
        }


        guard
            let latitudeRange = Range(match.range(at: 1), in: string),
            let longitudeRange = Range(match.range(at: 2), in: string)
        else {
            throw GraphQLError(message: "Coordinate regex failure")
        }

        let latitudeString = String(string[latitudeRange])
        let longitudeString = String(string[longitudeRange])

        guard
            let latitude = Double(latitudeString),
            let longitude = Double(longitudeString)
        else {
            throw GraphQLError(message: "Couldn't parse string values to doubles")
        }

        self.latitude = latitude
        self.longitude = longitude
    }

    init(from decoder: Decoder) throws {
        let string = try decoder.singleValueContainer().decode(String.self)
        try self.init(string)
    }

    func toString() -> String {
        return "(\(latitude), \(longitude))"
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(self.toString())
    }
}

struct DictCodedCoordinate : Codable {
    let latitude: Double
    let longitude: Double
    
    init(latitude: Double, longitude: Double) {
        self.latitude = latitude
        self.longitude = longitude
    }
}
