Add SendableRoute type

Package.swift

@@ -35,7 +35,7 @@ let package = Package(
 
         // Event-driven network application framework for high performance protocol servers & clients, non-blocking.
         .package(url: "https://github.com/apple/swift-nio.git", from: "2.62.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"),
 
@@ -120,9 +120,5 @@ let package = Package(
             .copy("Utilities/expired.crt"),
             .copy("Utilities/expired.key"),
         ]),
-        .testTarget(name: "AsyncTests", dependencies: [
-            .product(name: "NIOTestUtils", package: "swift-nio"),
-            .target(name: "XCTVapor"),
-        ]),
     ]
 )

Package@swift-5.9.swift

@@ -32,7 +32,7 @@ let package = Package(
 
         // Event-driven network application framework for high performance protocol servers & clients, non-blocking.
         .package(url: "https://github.com/apple/swift-nio.git", from: "2.62.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"),
 
@@ -133,16 +133,5 @@ let package = Package(
                 .enableExperimentalFeature("StrictConcurrency=complete"),
             ]
         ),
-        .testTarget(
-            name: "AsyncTests",
-            dependencies: [
-                .product(name: "NIOTestUtils", package: "swift-nio"),
-                .target(name: "XCTVapor"),
-            ],
-            swiftSettings: [
-                .enableUpcomingFeature("BareSlashRegexLiterals"),
-                .enableExperimentalFeature("StrictConcurrency=complete"),
-            ]
-        ),
     ]
 )

Sources/Development/routes.swift

@@ -132,7 +132,7 @@ public func routes(_ app: Application) throws {
     }
 
     let sessions = app.grouped("sessions")
-        .grouped(app.sessions.middleware)
+        .grouped(app.asyncSessions.middleware)
     sessions.get("set", ":value") { req -> HTTPStatus in
         req.session.data["name"] = req.parameters.get("value")
         return .ok
@@ -273,8 +273,8 @@ public func routes(_ app: Application) throws {
     }
     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
+    // Make sure no warnings with async middleware
+    asyncRoutes.grouped(TestAsyncMiddleware(number: 2), TestAsyncMiddleware(number: 4), TestAsyncMiddleware(number: 5)).get("middleware") { req async throws -> String in
         return "OK"
     }
 
@@ -341,15 +341,3 @@ struct TestAsyncMiddleware: AsyncMiddleware {
         return response
     }
 }
-
-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/Application.swift

@@ -142,6 +142,8 @@ public final class Application: Sendable {
         self.passwords.use(.bcrypt)
         self.sessions.initialize()
         self.sessions.use(.memory)
+        self.asyncSessions.initialize()
+        self.asyncSessions.use(.memory)
         self.responder.initialize()
         self.responder.use(.default)
         self.servers.initialize()

Sources/Vapor/Authentication/GuardMiddleware.swift

@@ -19,14 +19,14 @@ extension Authenticatable {
     ///     - throwing: `Error` to throw if the type is not authed.
     public static func guardMiddleware(
         throwing error: Error = Abort(.unauthorized, reason: "\(Self.self) not authenticated.")
-    ) -> Middleware {
+    ) -> AsyncMiddleware {
         return GuardAuthenticationMiddleware<Self>(throwing: error)
     }
 }
 
 
 
-private final class GuardAuthenticationMiddleware<A>: Middleware
+private final class GuardAuthenticationMiddleware<A>: AsyncMiddleware
     where A: Authenticatable
 {
     /// Error to throw when guard fails.
@@ -41,10 +41,10 @@ private final class GuardAuthenticationMiddleware<A>: Middleware
         self.error = error
     }
 
-    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
         guard request.auth.has(A.self) else {
-            return request.eventLoop.makeFailedFuture(self.error)
+            throw self.error
         }
-        return next.respond(to: request)
+        return try await next.respond(to: request)
     }
 }

Sources/Vapor/Authentication/RedirectMiddleware.swift

@@ -5,21 +5,21 @@ extension Authenticatable {
     ///
     /// - parameters:
     ///    - path: The path to redirect to if the request is not authenticated
-    public static func redirectMiddleware(path: String) -> Middleware {
+    public static func redirectMiddleware(path: String) -> AsyncMiddleware {
         self.redirectMiddleware(makePath: { _ in path })
     }
 
     /// Basic middleware to redirect unauthenticated requests to the supplied path
     ///
     /// - parameters:
     ///    - makePath: The closure that returns the redirect path based on the given `Request` object
-    @preconcurrency public static func redirectMiddleware(makePath: @Sendable @escaping (Request) -> String) -> Middleware {
+    @preconcurrency public static func redirectMiddleware(makePath: @Sendable @escaping (Request) -> String) -> AsyncMiddleware {
         RedirectMiddleware<Self>(Self.self, makePath: makePath)
     }
 }
 
 
-private final class RedirectMiddleware<A>: Middleware
+private final class RedirectMiddleware<A>: AsyncMiddleware
     where A: Authenticatable
 {
     let makePath: @Sendable (Request) -> String
@@ -28,12 +28,11 @@ private final class RedirectMiddleware<A>: Middleware
         self.makePath = makePath
     }
 
-    func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
         if request.auth.has(A.self) {
-            return next.respond(to: request)
+            return try await next.respond(to: request)
         }
 
-        let redirect = request.redirect(to: self.makePath(request))
-        return request.eventLoop.makeSucceededFuture(redirect)
+        return request.redirect(to: self.makePath(request))
     }
 }

Sources/Vapor/Commands/RoutesCommand.swift

@@ -27,9 +27,9 @@ public final class RoutesCommand: Command {
 
     public func run(using context: CommandContext, signature: Signature) throws {
         let routes = context.application.routes
-        let includeDescription = !routes.all.filter { $0.userInfo["description"] != nil }.isEmpty
+        let includeDescription = !routes.sendableAll.filter { $0.userInfo["description"] != nil }.isEmpty
         let pathSeparator = "/".consoleText()
-        context.console.outputASCIITable(routes.all.map { route -> [ConsoleText] in
+        context.console.outputASCIITable(routes.sendableAll.map { route -> [ConsoleText] in
             var column = [route.method.string.consoleText()]
             if route.path.isEmpty {
                 column.append(pathSeparator)

Sources/Vapor/Concurrency/AsyncMiddleware.swift

@@ -27,3 +27,49 @@ extension AsyncMiddleware {
         return promise.futureResult
     }
 }
+
+extension Array where Element == AsyncMiddleware {
+    /// Wraps an `AsyncResponder` in an array of `AsyncMiddleware` creating a new `AsyncResponder`.
+    /// - note: The array of middleware must be `[AsyncMiddleware]` not `[M] where M: AsyncMiddleware`.
+    public func makeAsyncResponder(chainingTo responder: AsyncResponder) -> AsyncResponder {
+        var responder = responder
+        for middleware in reversed() {
+            responder = middleware.makeAsyncResponder(chainingTo: responder)
+        }
+        return responder
+    }
+}
+
+public extension AsyncMiddleware {
+    /// Wraps a `Responder` in a single `Middleware` creating a new `Responder`.
+    func makeAsyncResponder(chainingTo responder: AsyncResponder) -> AsyncResponder {
+        return AsyncHTTPMiddlewareResponder(middleware: self, responder: responder)
+    }
+}
+
+private struct AsyncHTTPMiddlewareResponder: AsyncResponder {
+    var middleware: AsyncMiddleware
+    var responder: AsyncResponder
+
+    init(middleware: AsyncMiddleware, responder: AsyncResponder) {
+        self.middleware = middleware
+        self.responder = responder
+    }
+
+    /// Chains an incoming request to another `AsyncResponder` on the router.
+    /// - parameters:
+    ///     - request: The incoming `Request`.
+    /// - returns: An asynchronous `Response`.
+    func respond(to request: Request) async throws -> Response {
+        return try await self.middleware.respond(to: request, chainingTo: self.responder)
+    }
+}
+
+struct AsyncMiddlewareWrapper: AsyncMiddleware {
+
+    let middleware: Middleware
+
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+        try await middleware.respond(to: request, chainingTo: next).get()
+    }
+}

Sources/Vapor/Concurrency/Responder+Concurrency.swift

@@ -13,3 +13,15 @@ extension AsyncResponder {
         return promise.futureResult
     }
 }
+
+struct AsyncResponderWrapper: AsyncResponder {
+    let responder: Responder
+
+    init(_ responder: Responder) {
+        self.responder = responder
+    }
+
+    func respond(to request: Request) async throws -> Response {
+        try await self.responder.respond(to: request).get()
+    }
+}