Updated with enum Detail

Author: fabianfett

Sources/AWSLambdaEvents/Cloudwatch.swift

@@ -14,34 +14,129 @@
 
 import struct Foundation.Date
 
+/// EventBridge has the same payloads/notification types as CloudWatch
+typealias EventBridge = Cloudwatch
+
 public enum Cloudwatch {
     /// CloudWatch.Event is the outer structure of an event sent via CloudWatch Events.
     ///
-    /// **NOTE**: For examples of events that come via CloudWatch Events, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html
-    public struct Event<Detail: Decodable>: Decodable {
+    /// **NOTE**: For examples of events that come via CloudWatch Events, see
+    /// https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html
+    /// https://docs.aws.amazon.com/eventbridge/latest/userguide/event-types.html
+    public struct Event: Decodable {
         public let id: String
         public let source: String
         public let accountId: String
-
-        @ISO8601Coding
-        public var time: Date
+        public let time: Date
         public let region: AWSRegion
         public let resources: [String]
 
-        public let detailType: String
         public let detail: Detail
 
         enum CodingKeys: String, CodingKey {
             case id
-            case detailType = "detail-type"
             case source
             case accountId = "account"
             case time
             case region
             case resources
             case detail
         }
+      
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            
+            self.id = try container.decode(String.self, forKey: .id)
+            self.source = try container.decode(String.self, forKey: .source)
+            self.accountId = try container.decode(String.self, forKey: .accountId)
+            let time = try container.decode(ISO8601Coding.self, forKey: .time)
+            self.time = time.wrappedValue
+            self.region = try container.decode(AWSRegion.self, forKey: .region)
+            self.resources = try container.decode([String].self, forKey: .resources)
+          
+            self.detail = try Detail(from: decoder)
+        }
+
+
+        public enum Detail: Decodable {
+            case scheduled
+            case ec2InstanceStateChangeNotification(EC2.InstanceStateChangeNotification)
+            case ec2SpotInstanceInterruptionWarning(EC2.SpotInstanceInterruptionNotice)
+            case custom(label: String, detail: Decodable)
+
+            enum CodingKeys: String, CodingKey {
+                case detailType = "detail-type"
+                case detail
+            }
+
+            // FIXME: make thread safe
+            static var registry = [String: (Decoder) throws -> Decodable]()
+            public static func register<T: Decodable>(label: String, type: T.Type) {
+                registry[label] = type.init
+            }
+
+            public init(from decoder: Decoder) throws {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                let detailType = try container.decode(String.self, forKey: .detailType)
+                switch detailType {
+                case "Scheduled Event":
+                    self = .scheduled
+                case "EC2 Instance State-change Notification":
+                    self = .ec2InstanceStateChangeNotification(
+                        try container.decode(EC2.InstanceStateChangeNotification.self, forKey: .detail))
+                case "EC2 Spot Instance Interruption Warning":
+                    self = .ec2SpotInstanceInterruptionWarning(
+                        try container.decode(EC2.SpotInstanceInterruptionNotice.self, forKey: .detail))
+                default:
+                    guard let factory = Detail.registry[detailType] else {
+                        throw UnknownPayload()
+                    }
+                    let detailsDecoder = try container.superDecoder(forKey: .detail)
+                    self = .custom(label: detailType, detail: try factory(detailsDecoder))
+                }
+            }
+        }
     }
 
-    public struct ScheduledEvent: Codable {}
+    public struct CodePipelineStateChange: Decodable {
+        let foo: String
+    }
+
+    public enum EC2 {
+        public struct InstanceStateChangeNotification: Decodable {
+            public enum State: String, Codable {
+                case running
+                case shuttingDown = "shutting-down"
+                case stopped
+                case stopping
+                case terminated
+            }
+
+            public let instanceId: String
+            public let state: State
+
+            enum CodingKeys: String, CodingKey {
+                case instanceId = "instance-id"
+                case state
+            }
+        }
+
+        public struct SpotInstanceInterruptionNotice: Decodable {
+            public enum Action: String, Codable {
+                case hibernate
+                case stop
+                case terminate
+            }
+
+            public let instanceId: String
+            public let action: Action
+
+            enum CodingKeys: String, CodingKey {
+                case instanceId = "instance-id"
+                case action = "instance-action"
+            }
+        }
+    }
+  
+    struct UnknownPayload: Error {}
 }

Tests/AWSLambdaEventsTests/CloudwatchTests.swift

@@ -15,7 +15,7 @@
 @testable import AWSLambdaEvents
 import XCTest
 
-class CloudwatchTests: XCTestCase {
+ class CloudwatchTests: XCTestCase {
     static let scheduledEventPayload = """
     {
       "id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c",
@@ -33,20 +33,22 @@ class CloudwatchTests: XCTestCase {
 
     func testScheduledEventFromJSON() {
         let data = CloudwatchTests.scheduledEventPayload.data(using: .utf8)!
-        var maybeEvent: Cloudwatch.Event<Cloudwatch.ScheduledEvent>?
-        XCTAssertNoThrow(maybeEvent = try JSONDecoder().decode(Cloudwatch.Event<Cloudwatch.ScheduledEvent>.self, from: data))
+        var maybeEvent: Cloudwatch.Event?
+        XCTAssertNoThrow(maybeEvent = try JSONDecoder().decode(Cloudwatch.Event.self, from: data))
 
         guard let event = maybeEvent else {
-            XCTFail("Expected to have an event")
-            return
+          XCTFail("Expected to have an event"); return
         }
 
         XCTAssertEqual(event.id, "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c")
-        XCTAssertEqual(event.detailType, "Scheduled Event")
         XCTAssertEqual(event.source, "aws.events")
         XCTAssertEqual(event.accountId, "123456789012")
         XCTAssertEqual(event.time, Date(timeIntervalSince1970: 0))
         XCTAssertEqual(event.region, .us_east_1)
         XCTAssertEqual(event.resources, ["arn:aws:events:us-east-1:123456789012:rule/ExampleRule"])
+        
+        guard case Cloudwatch.Event.Detail.scheduled = event.detail else {
+          XCTFail("Unexpected detail: \(event.detail)"); return
+        }
     }
-}
+ }