[AHC Transport] Async bodies + swift-http-types adoption

Sources/OpenAPIAsyncHTTPClient/AsyncHTTPClientTransport.swift

@@ -16,6 +16,7 @@ import AsyncHTTPClient
 import NIOCore
 import NIOHTTP1
 import NIOFoundationCompat
+import HTTPTypes
 #if canImport(Darwin)
 import Foundation
 #else
@@ -100,15 +101,15 @@ public struct AsyncHTTPClientTransport: ClientTransport {
     internal enum Error: Swift.Error, CustomStringConvertible, LocalizedError {
 
         /// Invalid URL composed from base URL and received request.
-        case invalidRequestURL(request: OpenAPIRuntime.Request, baseURL: URL)
+        case invalidRequestURL(request: HTTPRequest, baseURL: URL)
 
         // MARK: CustomStringConvertible
 
         var description: String {
             switch self {
             case let .invalidRequestURL(request: request, baseURL: baseURL):
                 return
-                    "Invalid request URL from request path: \(request.path), query: \(request.query ?? "<nil>") relative to base URL: \(baseURL.absoluteString)"
+                    "Invalid request URL from request path: \(request.path ?? "<nil>") relative to base URL: \(baseURL.absoluteString)"
             }
         }
 
@@ -150,57 +151,94 @@ public struct AsyncHTTPClientTransport: ClientTransport {
     // MARK: ClientTransport
 
     public func send(
-        _ request: OpenAPIRuntime.Request,
+        _ request: HTTPRequest,
+        body: HTTPBody?,
         baseURL: URL,
         operationID: String
-    ) async throws -> OpenAPIRuntime.Response {
-        let httpRequest = try Self.convertRequest(request, baseURL: baseURL)
+    ) async throws -> (HTTPResponse, HTTPBody?) {
+        let httpRequest = try Self.convertRequest(request, body: body, baseURL: baseURL)
         let httpResponse = try await invokeSession(with: httpRequest)
-        let response = try await Self.convertResponse(httpResponse)
+        let response = try await Self.convertResponse(
+            method: request.method,
+            httpResponse: httpResponse
+        )
         return response
     }
 
     // MARK: Internal
 
     /// Converts the shared Request type into URLRequest.
     internal static func convertRequest(
-        _ request: OpenAPIRuntime.Request,
+        _ request: HTTPRequest,
+        body: HTTPBody?,
         baseURL: URL
     ) throws -> HTTPClientRequest {
         guard var baseUrlComponents = URLComponents(string: baseURL.absoluteString) else {
             throw Error.invalidRequestURL(request: request, baseURL: baseURL)
         }
-        baseUrlComponents.percentEncodedPath += request.path
-        baseUrlComponents.percentEncodedQuery = request.query
+        baseUrlComponents.percentEncodedPath += request.soar_pathOnly
+        baseUrlComponents.percentEncodedQuery = request.soar_query.map(String.init)
         guard let url = baseUrlComponents.url else {
             throw Error.invalidRequestURL(request: request, baseURL: baseURL)
         }
         var clientRequest = HTTPClientRequest(url: url.absoluteString)
         clientRequest.method = request.method.asHTTPMethod
         for header in request.headerFields {
-            clientRequest.headers.add(name: header.name.lowercased(), value: header.value)
+            clientRequest.headers.add(name: header.name.canonicalName, value: header.value)
         }
-        if let body = request.body {
-            clientRequest.body = .bytes(body)
+        if let body {
+            let length: HTTPClientRequest.Body.Length
+            switch body.length {
+            case .unknown:
+                length = .unknown
+            case .known(let count):
+                length = .known(count)
+            }
+            clientRequest.body = .stream(
+                body.map { .init(bytes: $0) },
+                length: length
+            )
         }
         return clientRequest
     }
 
     /// Converts the received URLResponse into the shared Response.
     internal static func convertResponse(
-        _ httpResponse: HTTPClientResponse
-    ) async throws -> OpenAPIRuntime.Response {
-        let headerFields: [OpenAPIRuntime.HeaderField] = httpResponse
-            .headers
-            .map { .init(name: $0, value: $1) }
-        let body = try await httpResponse.body.collect(upTo: .max)
-        let bodyData = Data(buffer: body, byteTransferStrategy: .noCopy)
-        let response = OpenAPIRuntime.Response(
-            statusCode: Int(httpResponse.status.code),
-            headerFields: headerFields,
-            body: bodyData
+        method: HTTPRequest.Method,
+        httpResponse: HTTPClientResponse
+    ) async throws -> (HTTPResponse, HTTPBody?) {
+
+        var headerFields: HTTPFields = [:]
+        for header in httpResponse.headers {
+            headerFields[.init(header.name)!] = header.value
+        }
+
+        let length: HTTPBody.Length
+        if let lengthHeaderString = headerFields[.contentLength],
+            let lengthHeader = Int(lengthHeaderString)
+        {
+            length = .known(lengthHeader)
+        } else {
+            length = .unknown
+        }
+
+        let body: HTTPBody?
+        switch method {
+        case .head, .connect, .trace:
+            body = nil
+        default:
+            body = HTTPBody(
+                httpResponse.body.map { $0.readableBytesView },
+                length: length,
+                iterationBehavior: .single
+            )
+        }
+
+        let response = HTTPResponse(
+            status: .init(code: Int(httpResponse.status.code)),
+            headerFields: headerFields
         )
-        return response
+        return (response, body)
     }
 
     // MARK: Private
@@ -215,7 +253,7 @@ public struct AsyncHTTPClientTransport: ClientTransport {
     }
 }
 
-extension OpenAPIRuntime.HTTPMethod {
+extension HTTPTypes.HTTPRequest.Method {
     var asHTTPMethod: NIOHTTP1.HTTPMethod {
         switch self {
         case .get:

Tests/OpenAPIAsyncHTTPClientTests/Test_AsyncHTTPClientTransport.swift

@@ -17,6 +17,7 @@ import NIOCore
 import NIOPosix
 import AsyncHTTPClient
 @testable import OpenAPIAsyncHTTPClient
+import HTTPTypes
 
 class Test_AsyncHTTPClientTransport: XCTestCase {
 
@@ -37,17 +38,17 @@ class Test_AsyncHTTPClientTransport: XCTestCase {
     }
 
     func testConvertRequest() throws {
-        let request: OpenAPIRuntime.Request = .init(
-            path: "/hello%20world/Maria",
-            query: "greeting=Howdy",
+        let request: HTTPRequest = .init(
+            soar_path: "/hello%20world/Maria?greeting=Howdy",
             method: .post,
             headerFields: [
-                .init(name: "content-type", value: "application/json")
-            ],
-            body: try Self.testData
+                .contentType: "application/json"
+            ]
         )
+        let requestBody = try HTTPBody(data: Self.testData)
         let httpRequest = try AsyncHTTPClientTransport.convertRequest(
             request,
+            body: requestBody,
             baseURL: try XCTUnwrap(URL(string: "http://example.com/api/v1"))
         )
         XCTAssertEqual(httpRequest.url, "http://example.com/api/v1/hello%20world/Maria?greeting=Howdy")
@@ -70,35 +71,44 @@ class Test_AsyncHTTPClientTransport: XCTestCase {
             ],
             body: .bytes(Self.testBuffer)
         )
-        let response = try await AsyncHTTPClientTransport.convertResponse(httpResponse)
-        XCTAssertEqual(response.statusCode, 200)
+        let (response, maybeResponseBody) = try await AsyncHTTPClientTransport.convertResponse(
+            method: .get,
+            httpResponse: httpResponse
+        )
+        let responseBody = try XCTUnwrap(maybeResponseBody)
+        XCTAssertEqual(response.status.code, 200)
         XCTAssertEqual(
             response.headerFields,
             [
-                .init(name: "content-type", value: "application/json")
+                .contentType: "application/json"
             ]
         )
-        XCTAssertEqual(response.body, try Self.testData)
+        let bufferedResponseBody = try await Data(collecting: responseBody, upTo: .max)
+        XCTAssertEqual(bufferedResponseBody, try Self.testData)
     }
 
     func testSend() async throws {
         let transport = AsyncHTTPClientTransport(
             configuration: .init(),
             requestSender: TestSender.test
         )
-        let request: OpenAPIRuntime.Request = .init(
-            path: "/api/v1/hello/Maria",
+        let request: HTTPRequest = .init(
+            soar_path: "/api/v1/hello/Maria",
             method: .get,
             headerFields: [
-                .init(name: "x-request", value: "yes")
+                .init("x-request")!: "yes"
             ]
         )
-        let response = try await transport.send(
+        let (response, maybeResponseBody) = try await transport.send(
             request,
+            body: nil,
             baseURL: Self.testUrl,
             operationID: "sayHello"
         )
-        XCTAssertEqual(response.statusCode, 200)
+        let responseBody = try XCTUnwrap(maybeResponseBody)
+        let bufferedResponseBody = try await String(collecting: responseBody, upTo: .max)
+        XCTAssertEqual(bufferedResponseBody, "[{}]")
+        XCTAssertEqual(response.status.code, 200)
     }
 }