Support Hummingbird 2.x.x (#8)

Joannis · web-flow · commit 61be1c2bd3c6 · 2024-01-18T12:24:07.000Z
* Support Hummingbird 2.x.x

* Update platform support

* Support a newer build of HB2

* Propagate HB's authority and scheme

* Conform HBRouter to ServerTransport

* HB2 now uses openapi-style capture syntax

* Process Adam's feedback
diff --git a/Package.swift b/Package.swift
@@ -6,14 +6,14 @@ import PackageDescription
 let package = Package(
     name: "swift-openapi-hummingbird",
     platforms: [
-        .macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v6),
+        .macOS(.v14), .iOS(.v17), .tvOS(.v17), .watchOS(.v10),
     ],
     products: [
         .library(name: "OpenAPIHummingbird", targets: ["OpenAPIHummingbird"]),
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
-        .package(url: "https://github.com/hummingbird-project/hummingbird.git", from: "1.8.3"),
+        .package(url: "https://github.com/hummingbird-project/hummingbird.git", branch: "2.x.x"),
     ],
     targets: [
         .target(
diff --git a/Sources/OpenAPIHummingbird/AsyncStreamerToByteChunkSequence.swift b/Sources/OpenAPIHummingbird/AsyncStreamerToByteChunkSequence.swift
diff --git a/Sources/OpenAPIHummingbird/OpenAPITransport.swift b/Sources/OpenAPIHummingbird/OpenAPITransport.swift
@@ -15,22 +15,10 @@
 import Foundation
 import HTTPTypes
 import Hummingbird
-import NIOFoundationCompat
 import NIOHTTP1
 import OpenAPIRuntime
 
-/// Hummingbird Transport for OpenAPI generator
-public struct HBOpenAPITransport: ServerTransport {
-    let application: HBApplication
-
-    /// Initialise ``HBOpenAPITransport``
-    /// - Parameter application: Hummingbird application
-    public init(_ application: HBApplication) {
-        self.application = application
-    }
-}
-
-extension HBOpenAPITransport {
+extension HBRouter: ServerTransport {
     /// Registers an HTTP operation handler at the provided path and method.
     /// - Parameters:
     ///   - handler: A handler to be invoked when an HTTP request is received.
@@ -45,65 +33,38 @@ extension HBOpenAPITransport {
         method: HTTPRequest.Method,
         path: String
     ) throws {
-        self.application.router.on(
-            Self.makeHummingbirdPath(from: path),
-            method: .init(rawValue: method.rawValue),
-            options: .streamBody
-        ) { request in
-            let (openAPIRequest, openAPIRequestBody) = try request.makeOpenAPIRequest()
-            let openAPIRequestMetadata = request.makeOpenAPIRequestMetadata()
-            let (openAPIResponse, openAPIResponseBody) = try await handler(
-                openAPIRequest,
-                openAPIRequestBody,
-                openAPIRequestMetadata
-            )
+        self.on(
+            path,
+            method: method
+        ) { request, context in
+            let (openAPIRequest, openAPIRequestBody) = try request.makeOpenAPIRequest(context: context)
+            let openAPIRequestMetadata = context.makeOpenAPIRequestMetadata()
+            let (openAPIResponse, openAPIResponseBody) = try await handler(openAPIRequest, openAPIRequestBody, openAPIRequestMetadata)
             return HBResponse(openAPIResponse, body: openAPIResponseBody)
         }
     }
-
-    /// Make hummingbird path string from OpenAPI path
-    static func makeHummingbirdPath(from path: String) -> String {
-        // frustratingly hummingbird supports `${parameter}` style path which is oh so close
-        // to the OpenAPI `{parameter}` format
-        return path.replacingOccurrences(of: "{", with: "${")
-    }
 }
 
 extension HBRequest {
     /// Construct ``OpenAPIRuntime.Request`` from Hummingbird ``HBRequest``
-    func makeOpenAPIRequest() throws -> (HTTPRequest, HTTPBody?) {
-        guard let method = HTTPRequest.Method(rawValue: self.method.rawValue) else {
-            // if we cannot create an OpenAPI http method then we can't create a
-            // a request and there is no handler for this method
-            throw HBHTTPError(.notFound)
-        }
-        var httpFields = HTTPFields()
-        for header in self.headers {
-            if let fieldName = HTTPField.Name(header.name) {
-                httpFields[fieldName] = header.value
-            }
-        }
-        let request = HTTPRequest(
-            method: method,
-            scheme: nil,
-            authority: nil,
-            path: self.uri.string,
-            headerFields: httpFields
-        )
+    func makeOpenAPIRequest<Context: HBBaseRequestContext>(context: Context) throws -> (HTTPRequest, HTTPBody?) {
+        let request = self.head
         let body: HTTPBody?
         switch self.body {
         case .byteBuffer(let buffer):
-            body = buffer.map { HTTPBody([UInt8](buffer: $0)) }
+            body = HTTPBody([UInt8](buffer: buffer))
         case .stream(let streamer):
             body = .init(
-                AsyncStreamerToByteChunkSequence(streamer: streamer),
+                streamer.map { [UInt8](buffer: $0) },
                 length: .unknown,
                 iterationBehavior: .single
             )
         }
         return (request, body)
     }
+}
 
+extension HBBaseRequestContext {
     /// Construct ``OpenAPIRuntime.ServerRequestMetadata`` from Hummingbird ``HBRequest``
     func makeOpenAPIRequestMetadata() -> ServerRequestMetadata {
         let keyAndValues = self.parameters.map { (key: String($0.0), value: $0.1) }
@@ -118,14 +79,15 @@ extension HBResponse {
     init(_ response: HTTPResponse, body: HTTPBody?) {
         let responseBody: HBResponseBody
         if let body = body {
-            let bufferSequence = body.map { ByteBuffer(bytes: $0) }
-            responseBody = .stream(AsyncSequenceResponseBodyStreamer(bufferSequence))
+            let bufferSequence = body.map { ByteBuffer(bytes: $0)}
+            responseBody = .init(asyncSequence: bufferSequence)
         } else {
-            responseBody = .empty
+            responseBody = .init(byteBuffer: ByteBuffer())
         }
+
         self.init(
-            status: .init(statusCode: response.status.code, reasonPhrase: response.status.reasonPhrase),
-            headers: .init(response.headerFields.map { (key: $0.name.canonicalName, value: $0.value) }),
+            status: response.status,
+            headers: response.headerFields,
             body: responseBody
         )
     }
diff --git a/Tests/OpenAPIHummingbirdTests/OpenAPITransportTests.swift b/Tests/OpenAPIHummingbirdTests/OpenAPITransportTests.swift
@@ -14,10 +14,12 @@
 
 import HTTPTypes
 import Hummingbird
+import HummingbirdCore
 import HummingbirdXCT
 import NIOCore
 import NIOHTTP1
 import OpenAPIRuntime
+import NIOHTTPTypes
 import XCTest
 
 @testable import OpenAPIHummingbird
@@ -29,26 +31,25 @@ extension HTTPField.Name {
 
 final class HBOpenAPITransportTests: XCTestCase {
     func test_requestConversion() async throws {
-        let app = HBApplication(testing: .live)
+        let router = HBRouter()
 
-        app.router.post("/hello/:name") { hbRequest -> HBResponse in
+        router.post("/hello/:name") { hbRequest, context -> HBResponse in
             // Hijack the request handler to test the request-conversion functions.
             let expectedRequest = HTTPRequest(
                 method: .post,
-                scheme: nil,
-                authority: nil,
+                scheme: "http",
+                authority: "localhost",
                 path: "/hello/Maria?greeting=Howdy",
                 headerFields: [
                     .xMumble: "mumble",
                     .connection: "keep-alive",
-                    .host: "localhost",
                     .contentLength: "4",
                 ]
             )
             let expectedRequestMetadata = ServerRequestMetadata(
                 pathParameters: ["name": "Maria"]
             )
-            let (request, body) = try hbRequest.makeOpenAPIRequest()
+            let (request, body) = try hbRequest.makeOpenAPIRequest(context: context)
             let collectedBody: [UInt8]
             if let body = body {
                 collectedBody = try await .init(collecting: body, upTo: .max)
@@ -57,80 +58,89 @@ final class HBOpenAPITransportTests: XCTestCase {
             }
             XCTAssertEqual(request, expectedRequest)
             XCTAssertEqual(collectedBody, [UInt8]("👋".utf8))
-            XCTAssertEqual(hbRequest.makeOpenAPIRequestMetadata(), expectedRequestMetadata)
+            XCTAssertEqual(context.makeOpenAPIRequestMetadata(), expectedRequestMetadata)
 
             // Use the response-conversion to create the HBRequest for returning.
             let response = HTTPResponse(status: .created, headerFields: [.xMumble: "mumble"])
             return HBResponse(response, body: .init([UInt8]("👋".utf8)))
         }
 
-        try app.XCTStart()
-        defer { app.XCTStop() }
-
-        try app.XCTExecute(
-            uri: "/hello/Maria?greeting=Howdy",
-            method: .POST,
-            headers: ["X-Mumble": "mumble"],
-            body: ByteBuffer(string: "👋")
-        ) { hbResponse in
-            // Check the HBResponse (created from the Response) is what meets expectations.
-            XCTAssertEqual(hbResponse.status, .created)
-            XCTAssertEqual(hbResponse.headers.first(name: "X-Mumble"), "mumble")
-            XCTAssertEqual(try String(buffer: XCTUnwrap(hbResponse.body)), "👋")
+        let app = HBApplication(responder: router.buildResponder())
+
+        try await app.test(.live) { client in
+            try await client.XCTExecute(
+                uri: "/hello/Maria?greeting=Howdy",
+                method: .post,
+                headers: [
+                    .xMumble: "mumble",
+                ],
+                body: ByteBuffer(string: "👋")
+            ) { hbResponse in
+                // Check the HBResponse (created from the Response) is what meets expectations.
+                XCTAssertEqual(hbResponse.status, .created)
+                XCTAssertEqual(hbResponse.headers[.xMumble], "mumble")
+                XCTAssertEqual(try String(buffer: XCTUnwrap(hbResponse.body)), "👋")
+            }
         }
     }
 
     func test_largeBody() async throws {
-        let app = HBApplication(testing: .live)
-        app.server.addChannelHandler(BreakupHTTPBodyChannelHandler())
-        let bytes = (0..<1_000_000).map { _ in UInt8.random(in: 0...255) }
+        let router = HBRouter()
+        let bytes = (0..<1_000_000).map { _ in UInt8.random(in: 0...255)}
         let byteBuffer = ByteBuffer(bytes: bytes)
 
-        app.router.post("/hello/:name") { hbRequest -> HBResponse in
+        router.post("/hello/:name") { hbRequest, context -> HBResponse in
             // Hijack the request handler to test the request-conversion functions.
             let expectedRequest = HTTPRequest(
                 method: .post,
-                scheme: nil,
-                authority: nil,
+                scheme: "http",
+                authority: "localhost",
                 path: "/hello/Maria?greeting=Howdy",
                 headerFields: [
                     .connection: "keep-alive",
-                    .host: "localhost",
                     .contentLength: "1000000",
                 ]
             )
             let expectedRequestMetadata = ServerRequestMetadata(
                 pathParameters: ["name": "Maria"]
             )
-            let (request, body) = try hbRequest.makeOpenAPIRequest()
+            let (request, body) = try hbRequest.makeOpenAPIRequest(context: context)
             XCTAssertEqual(request, expectedRequest)
-            XCTAssertEqual(hbRequest.makeOpenAPIRequestMetadata(), expectedRequestMetadata)
+            XCTAssertEqual(context.makeOpenAPIRequestMetadata(), expectedRequestMetadata)
 
             // Use the response-conversion to create the HBRequest for returning.
             let response = HTTPResponse(status: .ok)
             return HBResponse(response, body: body)
         }
 
-        try app.XCTStart()
-        defer { app.XCTStop() }
-
-        try app.XCTExecute(
-            uri: "/hello/Maria?greeting=Howdy",
-            method: .POST,
-            body: byteBuffer
-        ) { hbResponse in
-            // Check the HBResponse (created from the Response) is what meets expectations.
-            XCTAssertEqual(hbResponse.status, .ok)
-            XCTAssertEqual(byteBuffer, hbResponse.body)
+        let app = HBApplication(
+            router: router,
+            server: .http1(
+                additionalChannelHandlers: [
+                    BreakupHTTPBodyChannelHandler()
+                ]
+            )
+        )
+
+        try await app.test(.live) { client in
+            try await client.XCTExecute(
+                uri: "/hello/Maria?greeting=Howdy",
+                method: .post,
+                body: byteBuffer
+            ) { hbResponse in
+                // Check the HBResponse (created from the Response) is what meets expectations.
+                XCTAssertEqual(hbResponse.status, .ok)
+                XCTAssertEqual(byteBuffer, hbResponse.body)
+            }
         }
     }
 }
 
 /// To test streaming we need to break up the HTTP body into multiple chunks. This channel handler
 /// breaks up the incoming HTTP body into multiple chunks
 class BreakupHTTPBodyChannelHandler: ChannelInboundHandler, RemovableChannelHandler {
-    typealias InboundIn = HTTPServerRequestPart
-    typealias InboundOut = HTTPServerRequestPart
+    typealias InboundIn = HTTPRequestPart
+    typealias InboundOut = HTTPRequestPart
 
     func channelRead(context: ChannelHandlerContext, data: NIOAny) {
         let part = unwrapInboundIn(data)
