Add support for async/await

.github/workflows/test.yml

@@ -57,6 +57,11 @@ jobs:
         if: ${{ matrix.env.toolchain != '' }}
       - name: Check out Vapor
         uses: actions/checkout@v2
-      - name: Run tests with Thread Sanitizer
+      - name: Run main tests with Thread Sanitizer
+        timeout-minutes: 30
+        run: swift test --enable-test-discovery --filter VaporTests --sanitize=thread
+      - name: Run async tests without Thread Sanitizer
+        # TSAN and async aren't playing nice at the moment
         timeout-minutes: 30
-        run: swift test --enable-test-discovery --sanitize=thread
+        if: ${{ matrix.env.toolchain == '' }}
+        run: swift test --enable-test-discovery --filter AsyncTests

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
     dependencies: [
         // HTTP client library built on SwiftNIO
         .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.2.0"),
-    
+
         // Sugary extensions for the SwiftNIO library
         .package(url: "https://github.com/vapor/async-kit.git", from: "1.0.0"),
 
@@ -33,7 +33,7 @@ let package = Package(
         .package(url: "https://github.com/swift-server/swift-backtrace.git", from: "1.1.1"),
 
         // Event-driven network application framework for high performance protocol servers & clients, non-blocking.
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.18.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.33.0"),
 
         // Bindings to OpenSSL-compatible libraries for TLS support in SwiftNIO
         .package(url: "https://github.com/apple/swift-nio-ssl.git", from: "2.8.0"),
@@ -76,6 +76,7 @@ let package = Package(
             .product(name: "Logging", package: "swift-log"),
             .product(name: "Metrics", package: "swift-metrics"),
             .product(name: "NIO", package: "swift-nio"),
+            .product(name: "NIOCore", package: "swift-nio"),
             .product(name: "NIOExtras", package: "swift-nio-extras"),
             .product(name: "NIOFoundationCompat", package: "swift-nio"),
             .product(name: "NIOHTTPCompression", package: "swift-nio-extras"),
@@ -96,7 +97,9 @@ let package = Package(
             // Enable better optimizations when building in Release configuration. Despite the use of
             // the `.unsafeFlags` construct required by SwiftPM, this flag is recommended for Release
             // builds. See <https://github.com/swift-server/guides#building-for-production> for details.
-            .unsafeFlags(["-cross-module-optimization"], .when(configuration: .release))
+            .unsafeFlags([
+                            "-cross-module-optimization"
+            ], .when(configuration: .release)),
         ]),
 
         // Testing
@@ -107,5 +110,9 @@ let package = Package(
             .product(name: "NIOTestUtils", package: "swift-nio"),
             .target(name: "XCTVapor"),
         ]),
+        .testTarget(name: "AsyncTests", dependencies: [
+            .product(name: "NIOTestUtils", package: "swift-nio"),
+            .target(name: "XCTVapor"),
+        ]),
     ]
 )

Sources/Development/configure.swift

@@ -1,6 +1,8 @@
 import Vapor
 
 public func configure(_ app: Application) throws {
+    app.logger.logLevel = .debug
+
     app.http.server.configuration.hostname = "127.0.0.1"
     switch app.environment {
     case .tls:

Sources/Development/routes.swift

@@ -230,6 +230,79 @@ public func routes(_ app: Application) throws {
             return promise.futureResult
         }
     }
+
+    #if compiler(>=5.5) && canImport(_Concurrency)
+    if #available(macOS 12, *) {
+        let asyncRoutes = app.grouped("async").grouped(TestAsyncMiddleware(number: 1))
+        asyncRoutes.get("client") { req async throws -> String in
+            let response = try await req.client.get("https://www.google.com")
+            guard let body = response.body else {
+                throw Abort(.internalServerError)
+            }
+            return String(buffer: body)
+        }
+
+        func asyncRouteTester(_ req: Request) async throws -> String {
+            let response = try await req.client.get("https://www.google.com")
+            guard let body = response.body else {
+                throw Abort(.internalServerError)
+            }
+            return String(buffer: body)
+        }
+        asyncRoutes.get("client2", use: asyncRouteTester)
+
+        asyncRoutes.get("content", use: asyncContentTester)
+
+        func asyncContentTester(_ req: Request) async throws -> Creds {
+            return Creds(email: "name", password: "password")
+        }
+
+        asyncRoutes.get("content2") { req async throws -> Creds in
+            return Creds(email: "name", password: "password")
+        }
+
+        asyncRoutes.get("contentArray") { req async throws -> [Creds] in
+            let cred1 = Creds(email: "name", password: "password")
+            return [cred1]
+        }
+
+        func opaqueRouteTester(_ req: Request) async throws -> some AsyncResponseEncodable {
+            "Hello World"
+        }
+        asyncRoutes.get("opaque", use: opaqueRouteTester)
+
+        // Make sure jumping between multiple different types of middleware works
+        asyncRoutes.grouped(TestAsyncMiddleware(number: 2), TestMiddleware(number: 3), TestAsyncMiddleware(number: 4), TestMiddleware(number: 5)).get("middleware") { req async throws -> String in
+            return "OK"
+        }
+
+        let basicAuthRoutes = asyncRoutes.grouped(Test.authenticator(), Test.guardMiddleware())
+        basicAuthRoutes.get("auth") { req async throws -> String in
+            return try req.auth.require(Test.self).name
+        }
+    }
+
+    @available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+    struct Test: Authenticatable {
+        static func authenticator() -> AsyncAuthenticator {
+            TestAuthenticator()
+        }
+
+        var name: String
+    }
+
+    @available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+    struct TestAuthenticator: AsyncBasicAuthenticator {
+        typealias User = Test
+
+        func authenticate(basic: BasicAuthorization, for request: Request) async throws {
+            if basic.username == "test" && basic.password == "secret" {
+                let test = Test(name: "Vapor")
+                request.auth.login(test)
+            }
+        }
+    }
+    #endif
 }
 
 struct TestError: AbortError, DebuggableError {
@@ -262,3 +335,29 @@ struct TestError: AbortError, DebuggableError {
         self.stackTrace = stackTrace
     }
 }
+
+#if compiler(>=5.5) && canImport(_Concurrency)
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+struct TestAsyncMiddleware: AsyncMiddleware {
+    let number: Int
+
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+        request.logger.debug("In async middleware - \(number)")
+        let response = try await next.respond(to: request)
+        request.logger.debug("In async middleware way out - \(number)")
+        return response
+    }
+}
+#endif
+
+struct TestMiddleware: Middleware {
+    let number: Int
+
+    func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+        request.logger.debug("In non-async middleware - \(number)")
+        return next.respond(to: request).map { response in
+            request.logger.debug("In non-async middleware way out - \(self.number)")
+            return response
+        }
+    }
+}

Sources/Vapor/Concurrency/AnyResponse+Concurrency.swift

@@ -0,0 +1,54 @@
+#if compiler(>=5.5) && canImport(_Concurrency)
+import NIOCore
+
+/// A type erased response useful for routes that can return more than one type.
+///
+///     router.get("foo") { req -> AnyAsyncResponse in
+///         if /* something */ {
+///             return AnyAsyncResponse(42)
+///         } else {
+///             return AnyAsyncResponse("string")
+///         }
+///     }
+///
+/// This can also be done using a `AsyncResponseEncodable` enum.
+///
+///     enum IntOrString: AsyncResponseEncodable {
+///         case int(Int)
+///         case string(String)
+///
+///         func encode(for req: Request) throws -> EventLoopFuture<Response> {
+///             switch self {
+///             case .int(let i): return try i.encode(for: req)
+///             case .string(let s): return try s.encode(for: req)
+///             }
+///         }
+///     }
+///
+///     router.get("foo") { req -> IntOrString in
+///         if /* something */ {
+///             return .int(42)
+///         } else {
+///             return .string("string")
+///         }
+///     }
+///
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+public struct AnyAsyncResponse: AsyncResponseEncodable {
+    /// The wrapped `AsyncResponseEncodable` type.
+    private let encodable: AsyncResponseEncodable
+
+    /// Creates a new `AnyAsyncResponse`.
+    ///
+    /// - parameters:
+    ///     - encodable: Something `AsyncResponseEncodable`.
+    public init(_ encodable: AsyncResponseEncodable) {
+        self.encodable = encodable
+    }
+
+    public func encodeResponse(for request: Request) async throws -> Response {
+        return try await self.encodable.encodeResponse(for: request)
+    }
+}
+
+#endif

Sources/Vapor/Concurrency/AsyncBasicResponder.swift

@@ -0,0 +1,30 @@
+#if compiler(>=5.5) && canImport(_Concurrency)
+import NIOCore
+
+/// A basic, async closure-based `Responder`.
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+public struct AsyncBasicResponder: AsyncResponder {
+    /// The stored responder closure.
+    private let closure: (Request) async throws -> Response
+
+    /// Create a new `BasicResponder`.
+    ///
+    ///     let notFound: Responder = BasicResponder { req in
+    ///         let res = req.response(http: .init(status: .notFound))
+    ///         return req.eventLoop.newSucceededFuture(result: res)
+    ///     }
+    ///
+    /// - parameters:
+    ///     - closure: Responder closure.
+    public init(
+        closure: @escaping (Request) async throws -> Response
+    ) {
+        self.closure = closure
+    }
+
+    public func respond(to request: Request) async throws -> Response {
+        return try await closure(request)
+    }
+}
+
+#endif

Sources/Vapor/Concurrency/AsyncMiddleware.swift

@@ -0,0 +1,34 @@
+#if compiler(>=5.5) && canImport(_Concurrency)
+import NIOCore
+
+/// `AsyncMiddleware` is placed between the server and your router. It is capable of
+/// mutating both incoming requests and outgoing responses. `AsyncMiddleware` can choose
+/// to pass requests on to the next `AsyncMiddleware` in a chain, or they can short circuit and
+/// return a custom `Response` if desired.
+///
+/// This is an async version of `Middleware`
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+public protocol AsyncMiddleware: Middleware {
+    /// Called with each `Request` that passes through this middleware.
+    /// - parameters:
+    ///     - request: The incoming `Request`.
+    ///     - next: Next `Responder` in the chain, potentially another middleware or the main router.
+    /// - returns: An asynchronous `Response`.
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response
+}
+
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+extension AsyncMiddleware {
+    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+        let promise = request.eventLoop.makePromise(of: Response.self)
+        promise.completeWithTask {
+            let asyncResponder = AsyncBasicResponder { req in
+                return try await next.respond(to: req).get()
+            }
+            return try await respond(to: request, chainingTo: asyncResponder)
+        }
+        return promise.futureResult
+    }
+}
+
+#endif

Sources/Vapor/Concurrency/AsyncPasswordHasher+Concurrency.swift

@@ -0,0 +1,30 @@
+#if compiler(>=5.5) && canImport(_Concurrency)
+import NIOCore
+
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+extension AsyncPasswordHasher {
+    public func hash<Password>(_ password: Password) async throws -> [UInt8]
+        where Password: DataProtocol
+    {
+        try await self.hash(password).get()
+    }
+
+    public func verify<Password, Digest>(
+        _ password: Password,
+        created digest: Digest
+    ) async throws -> Bool
+        where Password: DataProtocol, Digest: DataProtocol
+    {
+        try await self.verify(password, created: digest).get()
+    }
+
+    public func hash(_ password: String) async throws -> String {
+        try await self.hash(password).get()
+    }
+
+    public func verify(_ password: String, created digest: String) async throws -> Bool {
+        try await self.verify(password, created: digest).get()
+    }
+}
+
+#endif

Sources/Vapor/Concurrency/AsyncSessionDriver.swift

@@ -0,0 +1,50 @@
+#if compiler(>=5.5) && canImport(_Concurrency)
+import NIOCore
+
+/// Capable of managing CRUD operations for `Session`s.
+///
+/// This is an async version of `SessionDriver`
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+public protocol AsyncSessionDriver: SessionDriver {
+    func createSession(_ data: SessionData, for request: Request) async throws -> SessionID
+    func readSession(_ sessionID: SessionID, for request: Request) async throws -> SessionData?
+    func updateSession(_ sessionID: SessionID, to data: SessionData, for request: Request) async throws -> SessionID
+    func deleteSession(_ sessionID: SessionID, for request: Request) async throws
+}
+
+@available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
+extension AsyncSessionDriver {
+    public func createSession(_ data: SessionData, for request: Request) -> EventLoopFuture<SessionID> {
+        let promise = request.eventLoop.makePromise(of: SessionID.self)
+        promise.completeWithTask {
+            try await self.createSession(data, for: request)
+        }
+        return promise.futureResult
+    }
+
+    public func readSession(_ sessionID: SessionID, for request: Request) -> EventLoopFuture<SessionData?> {
+        let promise = request.eventLoop.makePromise(of: SessionData?.self)
+        promise.completeWithTask {
+            try await self.readSession(sessionID, for: request)
+        }
+        return promise.futureResult
+    }
+
+    public func updateSession(_ sessionID: SessionID, to data: SessionData, for request: Request) -> EventLoopFuture<SessionID> {
+        let promise = request.eventLoop.makePromise(of: SessionID.self)
+        promise.completeWithTask {
+            try await self.updateSession(sessionID, to: data, for: request)
+        }
+        return promise.futureResult
+    }
+
+    public func deleteSession(_ sessionID: SessionID, for request: Request) -> EventLoopFuture<Void> {
+        let promise = request.eventLoop.makePromise(of: Void.self)
+        promise.completeWithTask {
+            try await self.deleteSession(sessionID, for: request)
+        }
+        return promise.futureResult
+    }
+}
+
+#endif