Allow transforming a Context using a function, and allow a request to be initializable without source (just by callback)

Author: Joannis

Sources/Hummingbird/Router/RouterMethods.swift

@@ -72,9 +72,8 @@ extension RouterMethods {
     /// ```
     /// - Parameters
     ///   - path: path prefix to add to routes inside this group
-    ///   - convertContext: Function converting context
     @discardableResult public func group<TargetContext>(
-        _ path: RouterPath,
+        _ path: RouterPath = "",
         context: TargetContext.Type
     ) -> RouterGroup<TargetContext> where TargetContext.Source == Context {
         return RouterGroup(
@@ -83,6 +82,29 @@ extension RouterMethods {
         )
     }
 
+    /// Return a group inside the current group that transforms the ``RequestContext``
+    ///
+    /// To transform the context, a function that maps between the two types is provided.
+    /// ```
+    /// router.group { request, oldContext -> NewContext in
+    ///     NewContext(
+    ///         coreContext: oldContext.coreContext
+    ///     )
+    /// }
+    /// ```
+    /// - Parameters
+    ///   - path: path prefix to add to routes inside this group
+    ///   - mapContext: Function converting context
+    @discardableResult public func group<TargetContext>(
+        _ path: RouterPath = "",
+        mapContext: @escaping @Sendable (Request, Context) async throws -> TargetContext
+    ) -> RouterGroup<TargetContext> {
+        return RouterGroup(
+            path: path,
+            parent: TransformingRouterGroup(parent: self, transform: mapContext)
+        )
+    }
+
     /// Add middleware stack to router
     ///
     /// Add multiple middleware to the router using the middleware stack result builder

Sources/Hummingbird/Router/TransformingRouterGroup.swift

@@ -17,22 +17,35 @@ import HummingbirdCore
 import NIOCore
 
 /// Internally used to transform RequestContext
-struct TransformingRouterGroup<InputContext: RequestContext, Context: RequestContext>: RouterMethods where Context.Source == InputContext {
+struct TransformingRouterGroup<InputContext: RequestContext, Context: RequestContext>: RouterMethods {
     typealias TransformContext = Context
     let parent: any RouterMethods<InputContext>
+    let transform: @Sendable (Request, InputContext) async throws -> TransformContext
 
     struct ContextTransformingResponder: HTTPResponder {
         typealias Context = InputContext
         let responder: any HTTPResponder<TransformContext>
+        let transform: @Sendable (Request, InputContext) async throws -> TransformContext
 
         func respond(to request: Request, context: InputContext) async throws -> Response {
-            let newContext = TransformContext(source: context)
+            let newContext = try await transform(request, context)
             return try await self.responder.respond(to: request, context: newContext)
         }
     }
 
-    init(parent: any RouterMethods<InputContext>) {
+    init(parent: any RouterMethods<InputContext>) where Context.Source == InputContext {
         self.parent = parent
+        self.transform = { _, context in
+            TransformContext(source: context)
+        }
+    }
+
+    init(
+        parent: any RouterMethods<InputContext>,
+        transform: @escaping @Sendable (Request, InputContext) async throws -> TransformContext
+    ) {
+        self.parent = parent
+        self.transform = transform
     }
 
     /// Add middleware (Stub function as it isn't used)
@@ -52,7 +65,10 @@ struct TransformingRouterGroup<InputContext: RequestContext, Context: RequestCon
         method: HTTPRequest.Method,
         responder: Responder
     ) -> Self where Responder.Context == Context {
-        let transformResponder = ContextTransformingResponder(responder: responder)
+        let transformResponder = ContextTransformingResponder(
+            responder: responder,
+            transform: transform
+        )
         self.parent.on(path, method: method, responder: transformResponder)
         return self
     }

Sources/Hummingbird/Server/RequestContext.swift

@@ -73,6 +73,18 @@ public protocol RequestContext: InitializableFromSource, RequestContextSource {
     var responseEncoder: Encoder { get }
 }
 
+extension Never: RequestContextSource {
+    public var logger: Logger {
+        fatalError("This can never be reached")
+    }
+}
+
+extension RequestContext where Source == Never {
+    public init(source: Source) {
+        fatalError("This can never be reached")
+    }
+}
+
 extension RequestContext {
     /// Logger to use with Request
     @inlinable