URLEncodedForm date encoding strategy

Sources/Vapor/URLEncodedForm/DateFormatter+threadSpecific.swift

@@ -0,0 +1,24 @@
+//
+//  File.swift
+//  
+//
+//  Created by Ravneet Singh on 3/29/20.
+//
+
+import NIO
+
+fileprivate final class ISO8601 {
+    fileprivate static let thread: ThreadSpecificVariable<ISO8601DateFormatter> = .init()
+}
+
+extension ISO8601DateFormatter {
+    static var threadSpecific: ISO8601DateFormatter {
+        if let existing = ISO8601.thread.currentValue {
+            return existing
+        } else {
+            let new = ISO8601DateFormatter()
+            ISO8601.thread.currentValue = new
+            return new
+        }
+    }
+}

Sources/Vapor/URLEncodedForm/URLEncodedFormDecoder.swift

@@ -13,9 +13,21 @@
 public struct URLEncodedFormDecoder: ContentDecoder, URLQueryDecoder {
     /// Used to capture URLForm Coding Configuration used for decoding
     public struct Configuration {
+        /// Supported date formats
+        public enum DateFormat {
+            /// Seconds since 00:00:00 UTC on 1 January 2001
+            case timeIntervalSinceReferenceDate
+            /// Seconds since  00:00:00 UTC on 1 January 1970
+            case timeIntervalSince1970
+            /// ISO 8601 formatted date
+            case iso8601
+            /// Using custom callback
+            case custom((Decoder) throws -> Date)
+        }
+
         let boolFlags: Bool
         let arraySeparators: [Character]
-
+        let dateFormat: DateFormat
         /// Creates a new `URLEncodedFormCodingConfiguration`.
         /// - parameters:
         ///     - boolFlags: Set to `true` allows you to parse `flag1&flag2` as boolean variables
@@ -26,10 +38,12 @@ public struct URLEncodedFormDecoder: ContentDecoder, URLQueryDecoder {
         ///                        populate a key named `arr` of type `Array` to be decoded as `["v1", "v2"]`
         public init(
             boolFlags: Bool = true,
-            arraySeparators: [Character] = [",", "|"]
+            arraySeparators: [Character] = [",", "|"],
+            dateFormat: DateFormat = .iso8601
         ) {
             self.boolFlags = boolFlags
             self.arraySeparators = arraySeparators
+            self.dateFormat = dateFormat
         }
     }
 
@@ -175,7 +189,25 @@ private struct _Decoder: Decoder {
                 }
             } else {
                 let decoder = _Decoder(data: child, codingPath: self.codingPath + [key], configuration: configuration)
-                return try T(from: decoder)
+                if type == Date.self {
+                    switch configuration.dateFormat {
+                    case .timeIntervalSince1970:
+                        return Date(timeIntervalSince1970: try TimeInterval(from: decoder)) as! T
+                    case .timeIntervalSinceReferenceDate:
+                        return Date(timeIntervalSinceReferenceDate: try TimeInterval(from: decoder)) as! T
+                    case .iso8601:
+                        //Creating a new `ISO8601DateFormatter` everytime is probably not performant
+                        if let date = ISO8601DateFormatter.threadSpecific.date(from: try String(from: decoder)) {
+                            return date as! T
+                        } else {
+                            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath, debugDescription: "Unable to decode date. Expecting ISO8601 formatted date"))
+                        }
+                    case .custom(let callback):
+                        return try callback(decoder) as! T
+                    }
+                } else {
+                    return try T(from: decoder)
+                }
             }
         }
 

Sources/Vapor/URLEncodedForm/URLEncodedFormEncoder.swift

@@ -1,3 +1,5 @@
+import NIO
+
 /// Encodes `Encodable` instances to `application/x-www-form-urlencoded` data.
 ///
 ///     print(user) /// User
@@ -27,15 +29,31 @@ public struct URLEncodedFormEncoder: ContentEncoder, URLQueryEncoder {
             case values
         }
 
+        /// Supported date formats
+        public enum DateFormat {
+            /// Seconds since 00:00:00 UTC on 1 January 2001
+            case timeIntervalSinceReferenceDate
+            /// Seconds since  00:00:00 UTC on 1 January 1970
+            case timeIntervalSince1970
+            /// ISO 8601 formatted date
+            case iso8601
+            /// Using custom callback
+            case custom((Date, Encoder) throws -> Void)
+        }
         /// Specified array encoding.
         public var arrayEncoding: ArrayEncoding
+        public var dateFormat: DateFormat
 
         /// Creates a new `Configuration`.
         ///
         ///  - parameters:
         ///     - arrayEncoding: Specified array encoding. Defaults to `.bracket`.
-        public init(arrayEncoding: ArrayEncoding = .bracket) {
+        public init(
+            arrayEncoding: ArrayEncoding = .bracket,
+            dateFormat: DateFormat = .iso8601
+        ) {
             self.arrayEncoding = arrayEncoding
+            self.dateFormat = dateFormat
         }
     }
 
@@ -167,11 +185,25 @@ private class _Encoder: Encoder {
         func encode<T>(_ value: T, forKey key: Key) throws
             where T : Encodable
         {
-            if let convertible = value as? URLQueryFragmentConvertible {
+             if let convertible = value as? URLQueryFragmentConvertible {
                 internalData.children[key.stringValue] = URLEncodedFormData(values: [convertible.urlQueryFragmentValue])
             } else {
                 let encoder = _Encoder(codingPath: self.codingPath + [key], configuration: self.configuration)
-                try value.encode(to: encoder)
+                if let date = value as? Date {
+                    switch configuration.dateFormat {
+                    case .timeIntervalSince1970:
+                        try date.timeIntervalSince1970.encode(to: encoder)
+                    case .timeIntervalSinceReferenceDate:
+                        try date.timeIntervalSinceReferenceDate.encode(to: encoder)
+                    case .iso8601:
+                        //Creating a new `ISO8601DateFormatter` everytime is probably not performant
+                        try ISO8601DateFormatter.threadSpecific.string(from: date).encode(to: encoder)
+                    case .custom(let callback):
+                        try callback(date, encoder)
+                    }
+                } else {
+                    try value.encode(to: encoder)
+                }
                 self.internalData.children[key.stringValue] = try encoder.getData()
             }
         }

Tests/VaporTests/URLEncodedFormTests.swift

@@ -1,5 +1,6 @@
 @testable import Vapor
 import XCTest
+import NIO
 
 final class URLEncodedFormTests: XCTestCase {
     // MARK: Codable
@@ -114,6 +115,85 @@ final class URLEncodedFormTests: XCTestCase {
         XCTAssert(result.contains("isCool=true"))
     }
 
+    func testDateCoding() throws {
+        let toEncode = DateCoding(date: Date(timeIntervalSince1970: 0))
+        let resultForTimeIntervalSince1970 = try URLEncodedFormEncoder(
+            configuration: .init(dateFormat: .timeIntervalSince1970)
+        ).encode(toEncode)
+        XCTAssertEqual("date=0.0", resultForTimeIntervalSince1970)
+
+        let decodedTimeIntervalSince1970 = try URLEncodedFormDecoder(
+            configuration: .init(dateFormat: .timeIntervalSince1970)
+        ).decode(DateCoding.self, from: resultForTimeIntervalSince1970)
+        XCTAssertEqual(decodedTimeIntervalSince1970, toEncode)
+
+        let resultForTimeIntervalSinceReferenceDate = try URLEncodedFormEncoder(
+            configuration: .init(dateFormat: .timeIntervalSinceReferenceDate)
+        ).encode(toEncode)
+        XCTAssertEqual("date=-978307200.0", resultForTimeIntervalSinceReferenceDate)
+
+        let decodedTimeIntervalSinceReferenceDate = try URLEncodedFormDecoder(
+            configuration: .init(dateFormat: .timeIntervalSinceReferenceDate)
+        ).decode(DateCoding.self, from: resultForTimeIntervalSinceReferenceDate)
+        XCTAssertEqual(decodedTimeIntervalSinceReferenceDate, toEncode)
+
+        let resultForInternetDateTime = try URLEncodedFormEncoder(
+            configuration: .init(dateFormat: .iso8601)
+        ).encode(toEncode)
+        XCTAssertEqual("date=1970-01-01T00:00:00Z", resultForInternetDateTime)
+
+        let decodedInternetDateTime = try URLEncodedFormDecoder(
+            configuration: .init(dateFormat: .iso8601)
+        ).decode(DateCoding.self, from: resultForInternetDateTime)
+        XCTAssertEqual(decodedInternetDateTime, toEncode)
+
+        XCTAssertThrowsError(try URLEncodedFormDecoder(
+            configuration: .init(dateFormat: .iso8601)
+        ).decode(DateCoding.self, from: "date=bad-date"))
+
+        class DateFormatterFactory {
+            private var threadSpecificValue = ThreadSpecificVariable<DateFormatter>()
+            var currentValue: DateFormatter {
+                get {
+                    guard let dateFormatter = threadSpecificValue.currentValue else {
+                        let threadSpecificDateFormatter = self.newDateFormatter
+                        threadSpecificValue.currentValue = threadSpecificDateFormatter
+                        return threadSpecificDateFormatter
+                    }
+                    return dateFormatter
+                }
+            }
+
+            private var newDateFormatter: DateFormatter {
+                let dateFormatter = DateFormatter()
+                dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+                dateFormatter.dateFormat = "'Date:' yyyy-MM-dd 'Time:' HH:mm:ss 'Timezone:' ZZZZZ"
+                dateFormatter.timeZone = TimeZone(secondsFromGMT: 0)
+                return dateFormatter
+            }
+        }
+        let factory = DateFormatterFactory()
+        let resultCustom = try URLEncodedFormEncoder(
+            configuration: .init(dateFormat: .custom({ (date, encoder) in
+                var container = encoder.singleValueContainer()
+                try container.encode(factory.currentValue.string(from: date))
+            }))
+        ).encode(toEncode)
+        XCTAssertEqual("date=Date:%201970-01-01%20Time:%2000:00:00%20Timezone:%20Z", resultCustom)
+
+        let decodedCustom = try URLEncodedFormDecoder(
+            configuration: .init(dateFormat: .custom({ (decoder) -> Date in
+                let container = try decoder.singleValueContainer()
+                let string = try container.decode(String.self)
+                guard let date = factory.currentValue.date(from: string) else {
+                    throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unable to decode date from string '\(string)'")
+                }
+                return date
+            }))
+        ).decode(DateCoding.self, from: resultCustom)
+        XCTAssertEqual(decodedCustom, toEncode)
+    }
+
     func testEncodedArrayValues() throws {
         let user = User(name: "Tanner", age: 23, pets: ["Zizek", "Foo"], dict: ["a": 1, "b": 2], foos: [.baz], nums: [3.14], isCool: true)
         let result = try URLEncodedFormEncoder(
@@ -469,3 +549,7 @@ private struct Users: Codable, Equatable {
 private enum Foo: String, Codable {
     case foo, bar, baz
 }
+
+struct DateCoding: Codable, Equatable {
+    let date: Date
+}