feat!: XML response deserialization (#644)

Author: jbelkins

Package.swift

@@ -36,7 +36,6 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/awslabs/aws-crt-swift.git", exact: "0.26.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
-        .package(url: "https://github.com/MaxDesiatov/XMLCoder.git", exact: "0.17.0")
     ],
     targets: [
         .target(
@@ -45,7 +44,6 @@ let package = Package(
                 "SmithyXML",
                 .product(name: "AwsCommonRuntimeKit", package: "aws-crt-swift"),
                 .product(name: "Logging", package: "swift-log"),
-                .product(name: "XMLCoder", package: "XMLCoder")
             ]
         ),
         .target(name: "SmithyReadWrite"),
@@ -71,7 +69,7 @@ let package = Package(
         ),
         .testTarget(
             name: "SmithyXMLTests",
-            dependencies: ["SmithyXML"]
+            dependencies: ["SmithyXML", "ClientRuntime"]
         ),
         .testTarget(
             name: "SmithyTimestampsTests",

Sources/ClientRuntime/EventStream/DefaultMessageDecoderStream.swift

@@ -8,28 +8,36 @@
 extension EventStream {
 
     /// Stream adapter that decodes input data into `EventStream.Message` objects.
-    public struct DefaultMessageDecoderStream<Event: MessageUnmarshallable>: MessageDecoderStream {
+    public struct DefaultMessageDecoderStream<Event>: MessageDecoderStream {
         public typealias Element = Event
 
         let stream: ReadableStream
         let messageDecoder: MessageDecoder
-        let responseDecoder: ResponseDecoder
+        let unmarshalClosure: UnmarshalClosure<Event>
 
-        public init(stream: ReadableStream, messageDecoder: MessageDecoder, responseDecoder: ResponseDecoder) {
+        public init(
+            stream: ReadableStream,
+            messageDecoder: MessageDecoder,
+            unmarshalClosure: @escaping UnmarshalClosure<Event>
+        ) {
             self.stream = stream
             self.messageDecoder = messageDecoder
-            self.responseDecoder = responseDecoder
+            self.unmarshalClosure = unmarshalClosure
         }
 
         public struct AsyncIterator: AsyncIteratorProtocol {
             let stream: ReadableStream
             let messageDecoder: MessageDecoder
-            let responseDecoder: ResponseDecoder
+            let unmarshalClosure: UnmarshalClosure<Event>
 
-            init(stream: ReadableStream, messageDecoder: MessageDecoder, responseDecoder: ResponseDecoder) {
+            init(
+                stream: ReadableStream,
+                messageDecoder: MessageDecoder,
+                unmarshalClosure: @escaping UnmarshalClosure<Event>
+            ) {
                 self.stream = stream
                 self.messageDecoder = messageDecoder
-                self.responseDecoder = responseDecoder
+                self.unmarshalClosure = unmarshalClosure
             }
 
             mutating public func next() async throws -> Event? {
@@ -42,8 +50,7 @@ extension EventStream {
 
                     // if we have a message in the decoder buffer, return it
                     if let message = try messageDecoder.message() {
-                        let event = try Element(message: message, decoder: responseDecoder)
-                        return event
+                        return try unmarshalClosure(message)
                     }
 
                     data = try await stream.readAsync(upToCount: Int.max)
@@ -61,7 +68,7 @@ extension EventStream {
             AsyncIterator(
                 stream: stream,
                 messageDecoder: messageDecoder,
-                responseDecoder: responseDecoder
+                unmarshalClosure: unmarshalClosure
             )
         }
     }

Sources/ClientRuntime/EventStream/MessageUnmarshallable.swift

@@ -16,3 +16,14 @@ public protocol MessageUnmarshallable {
     ///              using the same decoder.
     init(message: EventStream.Message, decoder: ResponseDecoder) throws
 }
+
+public typealias UnmarshalClosure<T> = (EventStream.Message) throws -> T
+
+/// Provides an `UnmarshalClosure` for event payloads that are Swift `Decodable`.
+/// - Parameter responseDecoder: The Swift `Decoder` to be used for decoding this event payload.
+/// - Returns: An `UnmarshalClosure` that uses the provided decoder to decode event payloads.
+public func jsonUnmarshalClosure<T: MessageUnmarshallable>(responseDecoder: ResponseDecoder) -> UnmarshalClosure<T> {
+    return { message in
+        try T(message: message, decoder: responseDecoder)
+    }
+}

Sources/ClientRuntime/Networking/Http/HTTPResponseClosure.swift

@@ -5,12 +5,34 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-public typealias HTTPResponseClosure<OperationStackOutput> = (HttpResponse) async throws -> OperationStackOutput
+public typealias HTTPResponseOutputClosure<OperationStackOutput> = (HttpResponse) async throws -> OperationStackOutput
 
+public typealias HTTPResponseOutputBinding<OperationStackOutput, Reader> =
+    (HttpResponse, HTTPResponseDocumentBinding<Reader>) async throws -> OperationStackOutput
+
+/// Provides a response closure for a type that conforms to the `HttpResponseBinding` decoding protocol.
+///
+/// This allows for use of JSON and FormURL serialized types with closure-based deserialization.
+/// - Parameter decoder: The decoder to be used for decoding the value.
+/// - Returns: A `HTTPResponseOutputClosure` that can be used to decode a value of the specified type.
 public func responseClosure<OperationStackOutput: HttpResponseBinding, Decoder: ResponseDecoder>(
     decoder: Decoder
-) -> HTTPResponseClosure<OperationStackOutput> {
+) -> HTTPResponseOutputClosure<OperationStackOutput> {
     return { response in
         try await OperationStackOutput(httpResponse: response, decoder: decoder)
     }
 }
+
+/// Provides a response closure for a type that provides closures for its output bindings.
+/// - Parameters:
+///   - responseOutputBinding: The `HTTPResponseOutputBinding` for the model to be deserialized.
+///   - responseDocumentBinding: A `HTTPResponseDocumentBinding` to convert the HTTP response to a `Reader`.
+/// - Returns: a `HTTPResponseOutputClosure` that can be used to deserialize a value of the specified type.
+public func responseClosure<OperationStackOutput, Reader>(
+    _ responseOutputBinding: @escaping HTTPResponseOutputBinding<OperationStackOutput, Reader>,
+    _ responseDocumentBinding: @escaping HTTPResponseDocumentBinding<Reader>
+) -> HTTPResponseOutputClosure<OperationStackOutput> {
+    return { response in
+        try await responseOutputBinding(response, responseDocumentBinding)
+    }
+}

Sources/ClientRuntime/Networking/Http/HTTPResponseDocumentBinding.swift

@@ -0,0 +1,19 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import class SmithyXML.Reader
+
+public typealias HTTPResponseDocumentBinding<Reader> = (HttpResponse) async throws -> Reader
+
+/// Creates a `HTTPResponseDocumentBinding` for converting a HTTP response into a `Reader`.
+public var responseDocumentBinding: HTTPResponseDocumentBinding<Reader> {
+    return { response in
+        let data = try await response.body.readData()
+        response.body = .data(data)
+        return try Reader.from(data: data ?? Data())
+    }
+}

Sources/ClientRuntime/Networking/Http/HTTPResponseErrorClosure.swift

@@ -5,8 +5,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+import class SmithyXML.Reader
+
+/// Defines a closure that can be used to convert a HTTP response to a Swift `Error`.
 public typealias HTTPResponseErrorClosure = (HttpResponse) async throws -> Error
 
+/// Defines a closure that can be used to convert a HTTP response and `Reader` for that response to a Swift `Error`.
+public typealias HTTPResponseErrorBinding<Reader> =
+    (HttpResponse, HTTPResponseDocumentBinding<Reader>) async throws -> Error
+
+/// Provides a `HTTPResponseErrorClosure` for types that have Swift Decodable-based deserialization.
+/// - Parameters:
+///   - errorBinding: The `HttpResponseErrorBinding`-conforming type for this operation.
+///   - decoder: The Swift `Decoder` to be used with the response.
+/// - Returns: The `HTTPResponseErrorClosure` for deserializing this error.
 public func responseErrorClosure<OperationErrorBinding: HttpResponseErrorBinding, Decoder: ResponseDecoder>(
     _ errorBinding: OperationErrorBinding.Type,
     decoder: Decoder
@@ -15,3 +27,17 @@ public func responseErrorClosure<OperationErrorBinding: HttpResponseErrorBinding
         try await OperationErrorBinding.makeError(httpResponse: response, decoder: decoder)
     }
 }
+
+/// Provides a `HTTPResponseErrorClosure` for types that have closure-based deserialization.
+/// - Parameters:
+///   - responseErrorBinding: The `HTTPResponseErrorBinding` closure for this operation.
+///   - responseDocumentBinding: The `HTTPResponseDocumentBinding` closure for converting the HTTP response into a `Reader`.
+/// - Returns: The `HTTPResponseErrorClosure` for deserializing this error.
+public func responseErrorClosure<Reader>(
+    _ responseErrorBinding: @escaping HTTPResponseErrorBinding<Reader>,
+    _ responseDocumentBinding: @escaping HTTPResponseDocumentBinding<Reader>
+) -> HTTPResponseErrorClosure {
+    return { response in
+        try await responseErrorBinding(response, responseDocumentBinding)
+    }
+}

Sources/ClientRuntime/Networking/Http/Middlewares/DeserializeMiddleware.swift

@@ -7,11 +7,11 @@
 
 public struct DeserializeMiddleware<OperationStackOutput>: Middleware {
     public var id: String = "Deserialize"
-    let httpResponseClosure: HTTPResponseClosure<OperationStackOutput>
+    let httpResponseClosure: HTTPResponseOutputClosure<OperationStackOutput>
     let httpResponseErrorClosure: HTTPResponseErrorClosure
 
     public init(
-        _ httpResponseClosure: @escaping HTTPResponseClosure<OperationStackOutput>,
+        _ httpResponseClosure: @escaping HTTPResponseOutputClosure<OperationStackOutput>,
         _ httpResponseErrorClosure: @escaping HTTPResponseErrorClosure
     ) {
         self.httpResponseClosure = httpResponseClosure

Sources/ClientRuntime/Networking/Http/SdkHttpRequest.swift

@@ -16,7 +16,7 @@ import struct Foundation.URLRequest
 // we need to maintain a reference to this same request while we add headers
 // in the CRT engine so that is why it's a class
 public class SdkHttpRequest {
-    public let body: ByteStream
+    public var body: ByteStream
     public let endpoint: Endpoint
     public let method: HttpMethodType
     private var additionalHeaders: Headers = Headers()
@@ -102,7 +102,9 @@ public extension URLRequest {
         self.httpMethod = sdkRequest.method.rawValue
         // Set body, handling any serialization errors
         do {
-            self.httpBody = try await sdkRequest.body.readData()
+            let data = try await sdkRequest.body.readData()
+            sdkRequest.body = .data(data)
+            self.httpBody = data
         } catch {
             throw ClientError.serializationFailed("Failed to construct URLRequest due to HTTP body conversion failure.")
         }

Sources/ClientRuntime/Networking/Http/URLSession/URLSessionConfiguration+HTTPClientConfiguration.swift

@@ -12,7 +12,7 @@ import class Foundation.URLSessionConfiguration
 extension URLSessionConfiguration {
 
     public static func from(httpClientConfiguration: HttpClientConfiguration) -> URLSessionConfiguration {
-        var config = URLSessionConfiguration.default
+        let config = URLSessionConfiguration.default
         if let connectTimeout = httpClientConfiguration.connectTimeout {
             config.timeoutIntervalForRequest = connectTimeout
         }

Sources/ClientRuntime/PrimitiveTypeExtensions/Indirect.swift

@@ -7,9 +7,9 @@
 
 @propertyWrapper
 public class Indirect<T> {
-    public var wrappedValue: T?
+    public var wrappedValue: Optional<T>
 
-    public init(wrappedValue: T? = nil) {
+    public init(wrappedValue: Optional<T>) {
         self.wrappedValue = wrappedValue
     }
 }