custom date parser

Author: t089

Package.swift

@@ -6,6 +6,7 @@ let swiftSettings: [SwiftSetting] = [.enableExperimentalFeature("StrictConcurren
 
 let package = Package(
     name: "swift-aws-lambda-events",
+    platforms: [.macOS(.v12)],
     products: [
         .library(name: "AWSLambdaEvents", targets: ["AWSLambdaEvents"])
     ],

Sources/AWSLambdaEvents/Utils/DateWrappers.swift

@@ -12,7 +12,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 
 @propertyWrapper
 public struct ISO8601Coding: Decodable, Sendable {
@@ -25,22 +29,16 @@ public struct ISO8601Coding: Decodable, Sendable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
         let dateString = try container.decode(String.self)
-        guard let date = Self.dateFormatter.date(from: dateString) else {
+        
+        do {
+            self.wrappedValue = try Date(dateString, strategy: .iso8601)
+        } catch {
             throw DecodingError.dataCorruptedError(
                 in: container,
                 debugDescription:
                     "Expected date to be in ISO8601 date format, but `\(dateString)` is not in the correct format"
             )
         }
-        self.wrappedValue = date
-    }
-
-    private static var dateFormatter: DateFormatter {
-        let formatter = DateFormatter()
-        formatter.locale = Locale(identifier: "en_US_POSIX")
-        formatter.timeZone = TimeZone(secondsFromGMT: 0)
-        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
-        return formatter
     }
 }
 
@@ -55,22 +53,19 @@ public struct ISO8601WithFractionalSecondsCoding: Decodable, Sendable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
         let dateString = try container.decode(String.self)
-        guard let date = Self.dateFormatter.date(from: dateString) else {
+        do {
+            self.wrappedValue = try Date(dateString, strategy: Self.iso8601WithFractionalSeconds)
+        } catch {
             throw DecodingError.dataCorruptedError(
                 in: container,
                 debugDescription:
                     "Expected date to be in ISO8601 date format with fractional seconds, but `\(dateString)` is not in the correct format"
             )
         }
-        self.wrappedValue = date
     }
 
-    private static var dateFormatter: DateFormatter {
-        let formatter = DateFormatter()
-        formatter.locale = Locale(identifier: "en_US_POSIX")
-        formatter.timeZone = TimeZone(secondsFromGMT: 0)
-        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ"
-        return formatter
+    private static var iso8601WithFractionalSeconds: Date.ISO8601FormatStyle {
+        Date.ISO8601FormatStyle(includingFractionalSeconds: true)
     }
 }
 
@@ -90,20 +85,18 @@ public struct RFC5322DateTimeCoding: Decodable, Sendable {
         if let bracket = string.firstIndex(of: "(") {
             string = String(string[string.startIndex..<bracket].trimmingCharacters(in: .whitespaces))
         }
-        for formatter in Self.dateFormatters {
-            if let date = formatter.date(from: string) {
-                self.wrappedValue = date
-                return
-            }
-        }
-        throw DecodingError.dataCorruptedError(
+        do {
+            self.wrappedValue = try Date(string, strategy: RFC5322DateStrategy())
+        } catch {
+            throw DecodingError.dataCorruptedError(
             in: container,
             debugDescription:
                 "Expected date to be in RFC5322 date-time format, but `\(string)` is not in the correct format"
-        )
+            )
+        }
     }
 
-    private static var dateFormatters: [DateFormatter] {
+    /*private static var dateFormatters: [DateFormatter] {
         // rfc5322 dates received in SES mails sometimes do not include the day, so need two dateformatters
         // one with a day and one without
         let formatterWithDay = DateFormatter()
@@ -113,5 +106,204 @@ public struct RFC5322DateTimeCoding: Decodable, Sendable {
         formatterWithoutDay.dateFormat = "d MMM yyy HH:mm:ss z"
         formatterWithoutDay.locale = Locale(identifier: "en_US_POSIX")
         return [formatterWithDay, formatterWithoutDay]
+    }*/
+}
+
+struct RFC5322DateError: Error {}
+
+struct RFC5322DateStrategy: ParseStrategy {
+    func parse(_ input: String) throws -> Date {
+        guard let components = self.components(from: input) else {
+            throw RFC5322DateError()
+        }
+        guard let date = components.date else {
+            throw RFC5322DateError()
+        }
+        return date
+    }
+
+    func components(from input: String) -> DateComponents? {
+        var s = input[...]
+        return s.withUTF8 { buffer -> DateComponents? in
+            // if the 4th character is a comma, then we have a day of the week
+            guard buffer.count > 5 else { return nil }
+            var offset = 0
+            if buffer[3] == UInt8(ascii: ",") {
+                offset = 5
+            }
+
+            func parseDay(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.next()
+                let second = it.next()
+                guard let first = first, let second = second else { return nil }
+                
+                guard first >= UInt8(ascii: "0") && first <= UInt8(ascii: "9") else { return nil }
+
+                if second >= UInt8(ascii: "0") && second <= UInt8(ascii: "9") {
+                    return Int(first - UInt8(ascii: "0")) * 10 + Int(second - UInt8(ascii: "0"))
+                } else {
+                    return Int(first - UInt8(ascii: "0"))
+                }
+            }
+
+            func skipWhitespace(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> UInt8? {
+                while let c = it.next() {
+                    if c != UInt8(ascii: " ") {
+                        return c
+                    }
+                }
+                return nil
+            }
+
+            func parseMonth(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.nextAsciiLetter(skippingWhitespace: true)
+                let second = it.nextAsciiLetter()
+                let third = it.nextAsciiLetter()
+                guard let first = first, let second = second, let third = third else { return nil }
+                guard first.isAsciiLetter else { return nil}
+                return monthMap[[first, second, third]]
+            }
+
+            func parseYear(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.nextAsciiNumber(skippingWhitespace: true)
+                let second = it.nextAsciiNumber()
+                let third = it.nextAsciiNumber()
+                let fourth = it.nextAsciiNumber()
+                guard let first = first, let second = second, let third = third, let fourth = fourth else { return nil }
+                return Int(first - UInt8(ascii: "0")) * 1000 + Int(second - UInt8(ascii: "0")) * 100 + Int(third - UInt8(ascii: "0")) * 10 + Int(fourth - UInt8(ascii: "0"))
+            }
+
+            func parseHour(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.nextAsciiNumber(skippingWhitespace: true)
+                let second = it.nextAsciiNumber()
+                guard let first = first, let second = second else { return nil }
+                return Int(first - UInt8(ascii: "0")) * 10 + Int(second - UInt8(ascii: "0"))
+            }
+
+            func parseMinute(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.nextAsciiNumber(skippingWhitespace: true)
+                let second = it.nextAsciiNumber()
+                guard let first = first, let second = second else { return nil }
+                return Int(first - UInt8(ascii: "0")) * 10 + Int(second - UInt8(ascii: "0"))
+            }
+
+            func parseSecond(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let first = it.nextAsciiNumber(skippingWhitespace: true)
+                let second = it.nextAsciiNumber()
+                guard let first = first, let second = second else { return nil }
+                return Int(first - UInt8(ascii: "0")) * 10 + Int(second - UInt8(ascii: "0"))
+            }
+
+            func parseTimezone(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
+                let plusMinus = it.nextSkippingWhitespace()
+                if let plusMinus, plusMinus == UInt8(ascii: "+") || plusMinus == UInt8(ascii: "-") {
+                    let hour = parseHour(&it)
+                    let minute = parseMinute(&it)
+                    guard let hour = hour, let minute = minute else { return nil }
+                    return (hour * 60 + minute) * (plusMinus == UInt8(ascii: "+") ? 1 : -1)
+                } else if let first = plusMinus {
+                    let second = it.nextAsciiLetter()
+                    let third = it.nextAsciiLetter()
+
+                    guard let second = second, let third = third else { return nil }
+                    let abbr = [first, second, third]
+                    return timezoneOffsetMap[abbr]
+                }
+
+                return nil
+            }
+
+            var it = buffer.makeIterator()
+
+            for _ in 0..<offset {
+                _ = it.next()
+            }
+            
+            guard let day = parseDay(&it) else { return nil }
+            guard let month = parseMonth(&it) else { return nil }
+            guard let year = parseYear(&it) else { return nil }
+
+            guard let hour = parseHour(&it) else { return nil }
+            guard it.expect(UInt8(ascii: ":")) else { return nil }
+            guard let minute = parseMinute(&it) else { return nil }
+            guard it.expect(UInt8(ascii: ":")) else { return nil }
+            guard let second = parseSecond(&it) else { return nil }
+
+            guard let timezoneOffset = parseTimezone(&it) else { return nil }
+
+            return DateComponents(
+                calendar: Calendar(identifier: .gregorian),
+                timeZone: TimeZone(secondsFromGMT: timezoneOffset * 60),
+                year: year,
+                month: month,
+                day: day,
+                hour: hour,
+                minute: minute,
+                second: second
+            )
+        }
+    }
+}
+
+extension IteratorProtocol where Self.Element == UInt8 {
+    mutating func expect(_ expected: UInt8) -> Bool {
+        guard self.next() == expected else { return false }
+        return true
+    }
+
+    mutating func nextSkippingWhitespace() -> UInt8? {
+        while let c = self.next() {
+            if c != UInt8(ascii: " ") {
+                return c
+            }
+        }
+        return nil
+    }
+
+    mutating func nextAsciiNumber(skippingWhitespace: Bool = false) -> UInt8? {
+        while let c = self.next() {
+            if skippingWhitespace {
+                if c == UInt8(ascii: " ") {
+                    continue
+                }
+            }
+            if c >= UInt8(ascii: "0") && c <= UInt8(ascii: "9") {
+                return c
+            } else {
+                return nil
+            }
+        }
+        return nil
+    }
+
+    mutating func nextAsciiLetter(skippingWhitespace: Bool = false) -> UInt8? {
+        while let c = self.next() {
+            if skippingWhitespace {
+                if c == UInt8(ascii: " ") {
+                    continue
+                }
+            }
+            if c >= UInt8(ascii: "A") && c <= UInt8(ascii: "Z") || c >= UInt8(ascii: "a") && c <= UInt8(ascii: "z") {
+                return c
+            } else {
+                return nil
+            }
+        }
+        return nil
+    }
+}
+
+extension UInt8 {
+    var isAsciiLetter: Bool {
+        return self >= UInt8(ascii: "A") && self <= UInt8(ascii: "Z") || self >= UInt8(ascii: "a") && self <= UInt8(ascii: "z")
     }
 }
+
+let monthMap : [Array<UInt8> : Int ] = [
+    Array("Jan".utf8): 1, Array("Feb".utf8): 2, Array("Mar".utf8): 3, Array("Apr".utf8): 4, Array("May".utf8): 5, Array("Jun".utf8): 6,
+    Array("Jul".utf8): 7, Array("Aug".utf8): 8, Array("Sep".utf8): 9, Array("Oct".utf8): 10, Array("Nov".utf8): 11, Array("Dec".utf8): 12
+]
+
+let timezoneOffsetMap: [Array<UInt8> : Int] = [
+    Array("UTC".utf8): 0, Array("GMT".utf8): 0, Array("EDT".utf8): -4 * 60, Array("CDT".utf8): -5 * 60, Array("MDT".utf8): -6 * 60, Array("PDT".utf8): -7 * 60
+]

Tests/AWSLambdaEventsTests/SNSTests.swift

@@ -72,7 +72,7 @@ class SNSTests: XCTestCase {
         XCTAssertEqual(record.sns.messageId, "bdb6900e-1ae9-5b4b-b7fc-c681fde222e3")
         XCTAssertEqual(record.sns.topicArn, "arn:aws:sns:eu-central-1:079477498937:EventSources-SNSTopic-1NHENSE2MQKF5")
         XCTAssertEqual(record.sns.message, "{\"hello\": \"world\"}")
-        XCTAssertEqual(record.sns.timestamp, Date(timeIntervalSince1970: 1_578_493_131.203))
+        XCTAssertEqual(record.sns.timestamp.timeIntervalSince1970, 1_578_493_131.203, accuracy: 0.001)
         XCTAssertEqual(record.sns.signatureVersion, "1")
         XCTAssertEqual(
             record.sns.signature,

Tests/AWSLambdaEventsTests/Utils/DateWrapperTests.swift

@@ -46,8 +46,8 @@ class DateWrapperTests: XCTestCase {
 
             XCTAssertEqual(context.codingPath.map(\.stringValue), ["date"])
             XCTAssertEqual(
-                context.debugDescription,
-                "Expected date to be in ISO8601 date format, but `\(date)` is not in the correct format"
+                "Expected date to be in ISO8601 date format, but `\(date)` is not in the correct format",
+                context.debugDescription
             )
             XCTAssertNil(context.underlyingError)
         }
@@ -63,7 +63,7 @@ class DateWrapperTests: XCTestCase {
         var event: TestEvent?
         XCTAssertNoThrow(event = try JSONDecoder().decode(TestEvent.self, from: json.data(using: .utf8)!))
 
-        XCTAssertEqual(event?.date, Date(timeIntervalSince1970: 1_585_241_585.123))
+        XCTAssertEqual(event?.date.timeIntervalSince1970 ?? 0.0, 1_585_241_585.123, accuracy: 0.001)
     }
 
     func testISO8601WithFractionalSecondsCodingWrapperFailure() {