Add ability to decode custom errors (#649)

* Start of decoding custom errors

* Cleanup. Added AWSErrorShape protocol

* Pass extended error to AWSErrorContext

* Remove any namespace from error codes

Author: adam-fowler

Sources/SotoCore/Doc/AWSShape.swift

@@ -193,6 +193,9 @@ extension AWSEncodableShape {
 /// AWSShape that can be decoded from API output
 public protocol AWSDecodableShape: AWSShape & Decodable {}
 
+/// AWSShape that can be decoded as an error
+public protocol AWSErrorShape: AWSShape & Decodable {}
+
 /// AWSShape options.
 public struct AWSShapeOptions: OptionSet, Sendable {
     public var rawValue: Int

Sources/SotoCore/Errors/Error.swift

@@ -28,31 +28,39 @@ public protocol AWSErrorType: Error, CustomStringConvertible {
 
 extension AWSErrorType {
     public var localizedDescription: String {
-        description
+        "\(self)"
     }
 
     public var message: String? {
         context?.message
     }
 }
 
+/// Service that has extended error information
+public protocol AWSServiceErrorType: AWSErrorType {
+    static var errorCodeMap: [String: AWSErrorShape.Type] { get }
+}
+
 /// Additional information about error
 public struct AWSErrorContext {
     public let message: String
     public let responseCode: HTTPResponseStatus
     public let headers: HTTPHeaders
     public let additionalFields: [String: String]
+    public let extendedError: AWSErrorShape?
 
     internal init(
         message: String,
         responseCode: HTTPResponseStatus,
         headers: HTTPHeaders = [:],
-        additionalFields: [String: String] = [:]
+        additionalFields: [String: String] = [:],
+        extendedError: AWSErrorShape? = nil
     ) {
         self.message = message
         self.responseCode = responseCode
         self.headers = headers
         self.additionalFields = additionalFields
+        self.extendedError = extendedError
     }
 }
 

Sources/SotoCore/HTTP/AWSHTTPResponse.swift

@@ -104,13 +104,17 @@ public struct AWSHTTPResponse: Sendable {
         case .byteBuffer(let buffer):
             switch serviceConfig.serviceProtocol {
             case .restjson:
-                apiError = try? JSONDecoder().decode(RESTJSONError.self, from: buffer)
+                let jsonDecoder = JSONDecoder()
+                jsonDecoder.userInfo[.awsErrorMap] = serviceConfig.errorType
+                apiError = try? jsonDecoder.decode(RESTJSONError.self, from: buffer)
                 if apiError?.code == nil {
                     apiError?.code = self.headers["x-amzn-errortype"].first
                 }
 
             case .json:
-                apiError = try? JSONDecoder().decode(JSONError.self, from: buffer)
+                let jsonDecoder = JSONDecoder()
+                jsonDecoder.userInfo[.awsErrorMap] = serviceConfig.errorType
+                apiError = try? jsonDecoder.decode(JSONError.self, from: buffer)
 
             case .query:
                 let xmlDocument = try? XML.Document(buffer: buffer)
@@ -119,15 +123,19 @@ public struct AWSHTTPResponse: Sendable {
                     element = errors
                 }
                 guard let errorElement = element.elements(forName: "Error").first else { break }
-                apiError = try? XMLDecoder().decode(XMLQueryError.self, from: errorElement)
+                var xmlDecoder = XMLDecoder()
+                xmlDecoder.userInfo[.awsErrorMap] = serviceConfig.errorType
+                apiError = try? xmlDecoder.decode(XMLQueryError.self, from: errorElement)
 
             case .restxml:
                 let xmlDocument = try? XML.Document(buffer: buffer)
                 guard var element = xmlDocument?.rootElement() else { break }
                 if let error = element.elements(forName: "Error").first {
                     element = error
                 }
-                apiError = try? XMLDecoder().decode(XMLQueryError.self, from: element)
+                var xmlDecoder = XMLDecoder()
+                xmlDecoder.userInfo[.awsErrorMap] = serviceConfig.errorType
+                apiError = try? xmlDecoder.decode(XMLQueryError.self, from: element)
 
             case .ec2:
                 let xmlDocument = try? XML.Document(buffer: buffer)
@@ -136,7 +144,9 @@ public struct AWSHTTPResponse: Sendable {
                     element = errors
                 }
                 guard let errorElement = element.elements(forName: "Error").first else { break }
-                apiError = try? XMLDecoder().decode(XMLQueryError.self, from: errorElement)
+                var xmlDecoder = XMLDecoder()
+                xmlDecoder.userInfo[.awsErrorMap] = serviceConfig.errorType
+                apiError = try? xmlDecoder.decode(XMLQueryError.self, from: errorElement)
             }
         }
         if let errorMessage = apiError, var code = errorMessage.code {
@@ -158,7 +168,8 @@ public struct AWSHTTPResponse: Sendable {
                 message: errorMessage.message,
                 responseCode: self.status,
                 headers: self.headers,
-                additionalFields: errorMessage.additionalFields
+                additionalFields: errorMessage.additionalFields,
+                extendedError: errorMessage.extendedError
             )
 
             if let errorType = serviceConfig.errorType {
@@ -181,17 +192,30 @@ public struct AWSHTTPResponse: Sendable {
     }
 
     /// Error used by XML output
-    private struct XMLQueryError: Codable, APIError {
+    private struct XMLQueryError: Decodable, APIError {
         var code: String?
         let message: String
         let additionalFields: [String: String]
+        let extendedError: AWSErrorShape?
 
         init(from decoder: Decoder) throws {
             // use `ErrorCodingKey` so we get extract additional keys from `container.allKeys`
             let container = try decoder.container(keyedBy: ErrorCodingKey.self)
-            self.code = try container.decodeIfPresent(String.self, forKey: .init("Code"))
+            let code = try container.decodeIfPresent(String.self, forKey: .init("Code"))
+            // Remove namespace from error code
+            self.code = code?.split(separator: "#").last.map { String($0) }
             self.message = try container.decode(String.self, forKey: .init("Message"))
 
+            if let code = self.code,
+                let errorMapping = decoder.userInfo[.awsErrorMap] as? AWSServiceErrorType.Type,
+                let errorType = errorMapping.errorCodeMap[code]
+            {
+                let container = try decoder.singleValueContainer()
+                self.extendedError = try? container.decode(errorType)
+            } else {
+                self.extendedError = nil
+            }
+
             var additionalFields: [String: String] = [:]
             for key in container.allKeys {
                 guard key.stringValue != "Code", key.stringValue != "Message" else { continue }
@@ -203,19 +227,31 @@ public struct AWSHTTPResponse: Sendable {
         }
     }
 
-    /// Error used by JSON output
     private struct JSONError: Decodable, APIError {
         var code: String?
         let message: String
         let additionalFields: [String: String]
+        let extendedError: AWSErrorShape?
 
         init(from decoder: Decoder) throws {
             // use `ErrorCodingKey` so we get extract additional keys from `container.allKeys`
             let container = try decoder.container(keyedBy: ErrorCodingKey.self)
-            self.code = try container.decodeIfPresent(String.self, forKey: .init("__type"))
+            let code = try container.decodeIfPresent(String.self, forKey: .init("__type"))
+            // Remove namespace from error code
+            self.code = code?.split(separator: "#").last.map { String($0) }
             self.message =
                 try container.decodeIfPresent(String.self, forKey: .init("message")) ?? container.decode(String.self, forKey: .init("Message"))
 
+            let errorMapping = decoder.userInfo[.awsErrorMap]
+            if let code = self.code,
+                let errorMapping = errorMapping as? AWSServiceErrorType.Type,
+                let errorType = errorMapping.errorCodeMap[code]
+            {
+                let container = try decoder.singleValueContainer()
+                self.extendedError = try? container.decode(errorType)
+            } else {
+                self.extendedError = nil
+            }
             var additionalFields: [String: String] = [:]
             for key in container.allKeys {
                 guard key.stringValue != "__type", key.stringValue != "message", key.stringValue != "Message" else { continue }
@@ -232,14 +268,27 @@ public struct AWSHTTPResponse: Sendable {
         var code: String?
         let message: String
         let additionalFields: [String: String]
+        let extendedError: AWSErrorShape?
 
         init(from decoder: Decoder) throws {
             // use `ErrorCodingKey` so we get extract additional keys from `container.allKeys`
             let container = try decoder.container(keyedBy: ErrorCodingKey.self)
-            self.code = try container.decodeIfPresent(String.self, forKey: .init("code"))
+            let code = try container.decodeIfPresent(String.self, forKey: .init("code"))
+            // Remove namespace from error code
+            self.code = code?.split(separator: "#").last.map { String($0) }
             self.message =
                 try container.decodeIfPresent(String.self, forKey: .init("message")) ?? container.decode(String.self, forKey: .init("Message"))
 
+            if let code = self.code,
+                let errorMapping = decoder.userInfo[.awsErrorMap] as? AWSServiceErrorType.Type,
+                let errorType = errorMapping.errorCodeMap[code]
+            {
+                let container = try decoder.singleValueContainer()
+                self.extendedError = try? container.decode(errorType)
+            } else {
+                self.extendedError = nil
+            }
+
             var additionalFields: [String: String] = [:]
             for key in container.allKeys {
                 guard key.stringValue != "code", key.stringValue != "message", key.stringValue != "Message" else { continue }
@@ -276,6 +325,7 @@ private protocol APIError {
     var code: String? { get set }
     var message: String { get }
     var additionalFields: [String: String] { get }
+    var extendedError: AWSErrorShape? { get }
 }
 
 extension XML.Document {
@@ -284,3 +334,7 @@ extension XML.Document {
         try self.init(string: xmlString)
     }
 }
+
+extension CodingUserInfoKey {
+    public static var awsErrorMap: Self { .init(rawValue: "soto.awsErrorMap")! }
+}

Tests/SotoCoreTests/AWSResponseTests.swift

@@ -356,6 +356,8 @@ class AWSResponseTests: XCTestCase {
         XCTAssertEqual(error?.message, "Don't like it")
         XCTAssertEqual(error?.context?.responseCode, .notFound)
         XCTAssertEqual(error?.context?.additionalFields["fault"], "client")
+        let contextError = try XCTUnwrap(error?.context?.extendedError as? ServiceErrorType.MessageRejected)
+        XCTAssertEqual(contextError.fault, "client")
     }
 
     func testEC2Error() async throws {
@@ -672,7 +674,11 @@ class AWSResponseTests: XCTestCase {
 
     // MARK: Types used in tests
 
-    struct ServiceErrorType: AWSErrorType, Equatable {
+    struct ServiceErrorType: AWSServiceErrorType, Equatable {
+        struct MessageRejected: AWSErrorShape {
+            let message: String?
+            let fault: String?
+        }
         enum Code: String {
             case resourceNotFoundException = "ResourceNotFoundException"
             case noSuchKey = "NoSuchKey"
@@ -682,6 +688,8 @@ class AWSResponseTests: XCTestCase {
         let error: Code
         let context: AWSErrorContext?
 
+        static let errorCodeMap: [String: AWSErrorShape.Type] = ["MessageRejected": MessageRejected.self]
+
         init?(errorCode: String, context: AWSErrorContext) {
             guard let error = Code(rawValue: errorCode) else { return nil }
             self.error = error