Make Middleware Async

Sources/Vapor/Middleware/CORSMiddleware.swift

@@ -6,7 +6,7 @@ import NIOCore
 ///
 /// - note: Make sure this middleware is inserted before all your error/abort middlewares,
 ///         so that even the failed request responses contain proper CORS information.
-public final class CORSMiddleware: Middleware {
+public final class CORSMiddleware: AsyncMiddleware {
     /// Option for the allow origin header in responses for CORS requests.
     ///
     /// - none: Disallows any origin.
@@ -122,45 +122,46 @@ public final class CORSMiddleware: Middleware {
     public init(configuration: Configuration = .default()) {
         self.configuration = configuration
     }
-
-    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+    
+    public func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
         // Check if it's valid CORS request
         guard request.headers[.origin].first != nil else {
-            return next.respond(to: request)
+            return try await next.respond(to: request)
         }
 
         // Determine if the request is pre-flight.
         // If it is, create empty response otherwise get response from the responder chain.
-        let response = request.isPreflight
-            ? request.eventLoop.makeSucceededFuture(.init())
-            : next.respond(to: request)
+        let response: Response
+        if request.isPreflight {
+            response = .init()
+        } else {
+            response = try await next.respond(to: request)
+        }
 
-        return response.map { response in
-            // Modify response headers based on CORS settings
-            let originBasedAccessControlAllowHeader = self.configuration.allowedOrigin.header(forRequest: request)
-            response.responseBox.withLockedValue { box in
-                box.headers.replaceOrAdd(name: .accessControlAllowOrigin, value: originBasedAccessControlAllowHeader)
-                box.headers.replaceOrAdd(name: .accessControlAllowHeaders, value: self.configuration.allowedHeaders)
-                box.headers.replaceOrAdd(name: .accessControlAllowMethods, value: self.configuration.allowedMethods)
-
-                if let exposedHeaders = self.configuration.exposedHeaders {
-                    box.headers.replaceOrAdd(name: .accessControlExpose, value: exposedHeaders)
-                }
-
-                if let cacheExpiration = self.configuration.cacheExpiration {
-                    box.headers.replaceOrAdd(name: .accessControlMaxAge, value: String(cacheExpiration))
-                }
-
-                if self.configuration.allowCredentials {
-                    box.headers.replaceOrAdd(name: .accessControlAllowCredentials, value: "true")
-                }
+        // Modify response headers based on CORS settings
+        let originBasedAccessControlAllowHeader = self.configuration.allowedOrigin.header(forRequest: request)
+        response.responseBox.withLockedValue { box in
+            box.headers.replaceOrAdd(name: .accessControlAllowOrigin, value: originBasedAccessControlAllowHeader)
+            box.headers.replaceOrAdd(name: .accessControlAllowHeaders, value: self.configuration.allowedHeaders)
+            box.headers.replaceOrAdd(name: .accessControlAllowMethods, value: self.configuration.allowedMethods)
+
+            if let exposedHeaders = self.configuration.exposedHeaders {
+                box.headers.replaceOrAdd(name: .accessControlExpose, value: exposedHeaders)
+            }
+
+            if let cacheExpiration = self.configuration.cacheExpiration {
+                box.headers.replaceOrAdd(name: .accessControlMaxAge, value: String(cacheExpiration))
+            }
+
+            if self.configuration.allowCredentials {
+                box.headers.replaceOrAdd(name: .accessControlAllowCredentials, value: "true")
+            }
 
-                if case .originBased = self.configuration.allowedOrigin, !originBasedAccessControlAllowHeader.isEmpty {
-                    box.headers.add(name: .vary, value: "origin")
-                }
+            if case .originBased = self.configuration.allowedOrigin, !originBasedAccessControlAllowHeader.isEmpty {
+                box.headers.add(name: .vary, value: "origin")
             }
-            return response
         }
+        return response
     }
 }
 

Sources/Vapor/Middleware/ErrorMiddleware.swift

@@ -3,7 +3,7 @@ import NIOCore
 import NIOHTTP1
 
 /// Captures all errors and transforms them into an internal server error HTTP response.
-public final class ErrorMiddleware: Middleware {
+public final class ErrorMiddleware: AsyncMiddleware {
     /// Structure of `ErrorMiddleware` default response.
     internal struct ErrorResponse: Codable {
         /// Always `true` to indicate this is a non-typical JSON response.
@@ -76,8 +76,10 @@ public final class ErrorMiddleware: Middleware {
         self.closure = closure
     }
 
-    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
-        return next.respond(to: request).flatMapErrorThrowing { error in
+    public func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+        do {
+            return try await next.respond(to: request)
+        } catch {
             return self.closure(request, error)
         }
     }

Sources/Vapor/Middleware/FileMiddleware.swift

@@ -4,7 +4,7 @@ import NIOCore
 /// Serves static files from a public directory.
 ///
 /// `FileMiddleware` will default to `DirectoryConfig`'s working directory with `"/Public"` appended.
-public final class FileMiddleware: Middleware {
+public final class FileMiddleware: AsyncMiddleware {
     /// The public directory. Guaranteed to end with a slash.
     private let publicDirectory: String
     private let defaultFile: String?
@@ -35,18 +35,18 @@ public final class FileMiddleware: Middleware {
         self.directoryAction = directoryAction
     }
 
-    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+    public func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
         // make a copy of the percent-decoded path
         guard var path = request.url.path.removingPercentEncoding else {
-            return request.eventLoop.makeFailedFuture(Abort(.badRequest))
+            throw Abort(.badRequest)
         }
 
         // path must be relative.
         path = path.removeLeadingSlashes()
 
         // protect against relative paths
         guard !path.contains("../") else {
-            return request.eventLoop.makeFailedFuture(Abort(.forbidden))
+            throw Abort(.forbidden)
         }
 
         // create absolute path
@@ -55,7 +55,7 @@ public final class FileMiddleware: Middleware {
         // check if path exists and whether it is a directory
         var isDir: ObjCBool = false
         guard FileManager.default.fileExists(atPath: absPath, isDirectory: &isDir) else {
-            return next.respond(to: request)
+            return try await next.respond(to: request)
         }
 
         if isDir.boolValue {
@@ -64,17 +64,15 @@ public final class FileMiddleware: Middleware {
                 case .redirect:                    
                     var redirectUrl = request.url
                     redirectUrl.path += "/"
-                    return request.eventLoop.future(
-                        request.redirect(to: redirectUrl.string, redirectType: .permanent)
-                    )
+                    return request.redirect(to: redirectUrl.string, redirectType: .permanent)
                 case .none:
-                    return next.respond(to: request)
+                    return try await next.respond(to: request)
                 }
             }
 
             // If a directory, check for the default file
             guard let defaultFile = defaultFile else {
-                return next.respond(to: request)
+                return try await next.respond(to: request)
             }
 
             if defaultFile.isAbsolute() {
@@ -85,13 +83,12 @@ public final class FileMiddleware: Middleware {
 
             // If the default file doesn't exist, pass on request
             guard FileManager.default.fileExists(atPath: absPath) else {
-                return next.respond(to: request)
+                return try await next.respond(to: request)
             }
         }
 
         // stream the file
-        let res = request.fileio.streamFile(at: absPath)
-        return request.eventLoop.makeSucceededFuture(res)
+        return request.fileio.streamFile(at: absPath)
     }
 
     /// Creates a new `FileMiddleware` for a server contained in an Xcode Project.

Sources/Vapor/Middleware/RouteLoggingMiddleware.swift

@@ -3,15 +3,15 @@ import Logging
 
 /// Emits a log message containing the request method and path to a `Request`'s logger.
 /// The log level of the message is configurable.
-public final class RouteLoggingMiddleware: Middleware {
+public final class RouteLoggingMiddleware: AsyncMiddleware {
     public let logLevel: Logger.Level
 
     public init(logLevel: Logger.Level = .info) {
         self.logLevel = logLevel
     }
 
-    public func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+    public func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
         request.logger.log(level: self.logLevel, "\(request.method) \(request.url.path.removingPercentEncoding ?? request.url.path)")
-        return next.respond(to: request)
+        return try await next.respond(to: request)
     }
 }