swift-format

Author: sebsto

Sources/Middleware/LoggingMiddleware.swift

@@ -21,11 +21,37 @@ import OpenAPIRuntime
 /// Only active at .trace level
 public struct LoggingMiddleware: ServerMiddleware {
 
-		private let logger: Logger
-		public init(logger: Logger) {
-				self.logger = logger
-		}
+    private let logger: Logger
 
+    /// A middleware that logs request and response metadata.
+    /// Only active at .trace level
+    ///
+    /// - Parameters:
+    ///   - logger: The logger instance to use for logging request/response data
+    ///
+    /// - Note: This middleware only logs at .trace level and will not generate output at other log levels
+    ///
+    public init(logger: Logger) {
+        self.logger = logger
+    }
+
+    /// Intercepts HTTP requests and logs request/response metadata at trace level.
+    ///
+    /// - Parameters:
+    ///   - request: The incoming HTTP request
+    ///   - body: The request body, if any
+    ///   - metadata: Metadata associated with the request
+    ///   - operationID: The OpenAPI operation ID for this request
+    ///   - next: The next middleware/handler in the chain
+    ///
+    /// - Returns: A tuple containing the HTTP response and optional response body
+    ///
+    /// - Throws: Rethrows any errors from downstream handlers
+    ///
+    /// This method logs:
+    /// - The request method and path on entry
+    /// - The response status code on successful completion
+    /// - Error descriptions if an error occurs
     public func intercept(
         _ request: HTTPRequest,
         body: HTTPBody?,
@@ -39,7 +65,8 @@ public struct LoggingMiddleware: ServerMiddleware {
             let (response, responseBody) = try await next(request, body, metadata)
             logger.trace("<<<: \(response.status.code)")
             return (response, responseBody)
-        } catch {
+        }
+        catch {
             logger.trace("!!!: \(error.localizedDescription)")
             throw error
         }

Sources/OpenAPILambdaHandler.swift

@@ -91,7 +91,9 @@ public struct OpenAPILambdaHandler<OALS: OpenAPILambdaService>: LambdaHandler, S
         catch OpenAPILambdaRouterError.noRouteForPath(let method, let path) {
 
             // There is no hadler registered for this path. This is a programming error.
-            lambdaResponse = (HTTPResponse(status: .notFound), "There is no route registered for the path \(method) \(path)")
+            lambdaResponse = (
+                HTTPResponse(status: .notFound), "There is no route registered for the path \(method) \(path)"
+            )
 
         }
         catch OpenAPILambdaHttpError.invalidMethod(let method) {

Sources/OpenAPILambdaService.swift

@@ -28,7 +28,7 @@ public protocol OpenAPILambdaService: Sendable {
     ///
     /// This is where your OpenAPILambdaService implementation must register the transport
     func register(transport: OpenAPILambdaTransport) throws
-    
+
     /// Convert from `Event` type to `OpenAPILambdaRequest`
     /// - Parameters:
     ///   - context: Lambda context
@@ -54,5 +54,3 @@ extension OpenAPILambdaService {
         try await lambdaRuntime.run()
     }
 }
-
-

Sources/Router/OpenAPILambdaRouterTrie.swift

@@ -32,33 +32,51 @@ final class TrieRouter: OpenAPILambdaRouter, CustomStringConvertible {
     ) {
         try self.uriPath.withLock { try $0.find(method: method, path: path) }
     }
-    
+
     var description: String {
         uriPath.withLock { uriPath in
             var routes: [String] = []
             collectRoutes(from: uriPath.root(), method: nil, path: "", parameters: [], routes: &routes)
             return routes.joined(separator: "\n")
         }
     }
-    
-    private func collectRoutes(from node: Node, method: HTTPRequest.Method?, path: String, parameters: [String], routes: inout [String]) {
+
+    private func collectRoutes(
+        from node: Node,
+        method: HTTPRequest.Method?,
+        path: String,
+        parameters: [String],
+        routes: inout [String]
+    ) {
         // If this node has a handler, we found a complete route
         if let _ = node.handlerChild(), let method = method {
             let paramString = parameters.isEmpty ? "" : " " + parameters.map { "\($0)=value" }.joined(separator: " ")
             routes.append("\(method.rawValue) \(path)\(paramString)")
         }
-        
+
         // Traverse all children
         for (_, child) in node.children {
             switch child.value {
             case .httpMethod(let httpMethod):
                 collectRoutes(from: child, method: httpMethod, path: path, parameters: parameters, routes: &routes)
             case .pathElement(let element):
-                collectRoutes(from: child, method: method, path: path + "/" + element, parameters: parameters, routes: &routes)
+                collectRoutes(
+                    from: child,
+                    method: method,
+                    path: path + "/" + element,
+                    parameters: parameters,
+                    routes: &routes
+                )
             case .pathParameter(let param):
                 var newParams = parameters
                 newParams.append(param)
-                collectRoutes(from: child, method: method, path: path + "/{\(param)}", parameters: newParams, routes: &routes)
+                collectRoutes(
+                    from: child,
+                    method: method,
+                    path: path + "/{\(param)}",
+                    parameters: newParams,
+                    routes: &routes
+                )
             case .handler, .root:
                 collectRoutes(from: child, method: method, path: path, parameters: parameters, routes: &routes)
             }