Make teh router and the Lambda service sendable

Author: sebsto

.swift-format

@@ -52,7 +52,7 @@
     "UseLetInEveryBoundCaseVariable" : false,
     "UseShorthandTypeNames" : true,
     "UseSingleLinePropertyGetter" : false,
-    "UseSynthesizedInitializer" : true,
+    "UseSynthesizedInitializer" : false,
     "UseWhereClausesInForLoops" : false
   },
   "spacesAroundRangeFormationOperators" : false,

Examples/quoteapi/Sources/QuoteAPI/QuoteService.swift

@@ -21,14 +21,16 @@ import OpenAPILambda
 @main
 struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi {
 
-    init(transport: OpenAPILambdaTransport) throws {
+    func register(transport: OpenAPILambdaTransport) throws {
         try self.registerHandlers(on: transport)
     }
 
     static func main() async throws {
 
         // when you just need to run the Lambda function, call Self.run()
-        try await Self.run()
+        // try await Self.run()
+
+        // =============================
 
         // when you need to have access to the runtime for advanced usage (dependency injection, Service LifeCycle, etc)
         // create the LambdaRuntime and run it
@@ -49,8 +51,29 @@ struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi {
         //     logger: Logger(label: "ServiceGroup")
         // )
         // try await serviceGroup.run()
+
+        // =============================
+
+        // When you need full control on this struct lifecycle, for example to inject dependencies,
+        // you can create your own instance of `OpenAPILambda`
+        // 1. add your custom init() function
+        // 2. create the class
+        // 3. create the lambda handler and pass this class to the initializer
+
+        // let openAPIService = QuoteServiceImpl(i: 42)
+        // let lambda = try OpenAPILambdaHandler(service: openAPIService)
+        // let lambdaHandler = lambda.handler
+        // let lambdaRuntime = LambdaRuntime(body: lambdaHandler)
+        // try await lambdaRuntime.run()
     }
 
+    // example of dependency injection when using a custom initializer
+    // let i: Int
+    // init(i: Int) {
+    //     self.i = i
+    // }
+    // init() { self.i = 0 } // to comply with protocol
+
     func getQuote(_ input: Operations.getQuote.Input) async throws -> Operations.getQuote.Output {
 
         let symbol = input.path.symbol

Sources/HttpApi/OpenAPILambdaHttpApi.swift

@@ -24,7 +24,7 @@ public enum OpenAPILambdaHttpError: Error {
 }
 
 /// An specialization of the `OpenAPILambda` protocol that works with Amazon API Gateway HTTP Mode, aka API Gateway v2
-public protocol OpenAPILambdaHttpApi: OpenAPILambda
+public protocol OpenAPILambdaHttpApi: OpenAPILambdaService
 where
     Event == APIGatewayV2Request,
     Output == APIGatewayV2Response

Sources/OpenAPILambda.swift

@@ -19,15 +19,18 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// A Lambda function implemented with a OpenAPI server (implementing `APIProtocol` from Swift OpenAPIRuntime)
-public protocol OpenAPILambda: Sendable {
+public protocol OpenAPILambdaService: Sendable {
 
     associatedtype Event: Decodable, Sendable
     associatedtype Output: Encodable, Sendable
 
-    /// Initialize application.
+    /// Create a new instance of the OpenAPILambdaService.
+    init()
+
+    /// Injects the transport.
     ///
-    /// This is where you create your OpenAPI service implementation and register the transport
-    init(transport: OpenAPILambdaTransport) throws
+    /// This is where your OpenAPILambdaService implementation must register the transport
+    func register(transport: OpenAPILambdaTransport) throws
 
     /// Convert from `Event` type to `OpenAPILambdaRequest`
     /// - Parameters:
@@ -40,8 +43,18 @@ public protocol OpenAPILambda: Sendable {
     func output(from: OpenAPILambdaResponse) -> Output
 }
 
-extension OpenAPILambda {
-    /// Returns the Lambda handler function for this OpenAPI Lambda implementation.
+extension OpenAPILambdaService {
+    /// Returns the Lambda handler function for this OpenAPILambdaService implementation.
+    /// Use this function when you create a vanilla OpenAPILambdaService and just need to access its handler
+    /// If you need to inject dependencies into your OpenAPILambdaService implementation,
+    /// write your own initializer, such as `init(dbConnection:)` on the OpenAPILambdaService implementation,
+    /// then create the OpenAPILambdaHandler and the LambdaRuntime manually.
+    /// For example:
+    ///         let openAPIService = QuoteServiceImpl(i: 42) // my custom OpenAPI service initializer
+    ///         let lambda = try OpenAPILambdaHandler(service: openAPIService)
+    ///         let lambdaRuntime = LambdaRuntime(body: lambda.handler)
+    ///         try await lambdaRuntime.run()
+    ///
     /// - Returns: A handler function that can be used with AWS Lambda Runtime
     public static func handler() throws -> (Event, LambdaContext) async throws -> Output {
         try OpenAPILambdaHandler<Self>().handler
@@ -51,7 +64,7 @@ extension OpenAPILambda {
     /// when one is given.
     /// - Parameter logger: The logger to use for Lambda runtime logging
     public static func run(logger: Logger? = nil) async throws {
-        let _logger = logger ?? Logger(label: "OpenAPILambda")
+        let _logger = logger ?? Logger(label: "OpenAPILambdaService")
         let lambdaRuntime = LambdaRuntime(logger: _logger, body: try Self.handler())
         try await lambdaRuntime.run()
     }

Sources/OpenAPILambdaHandler.swift

@@ -18,17 +18,17 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// Specialization of LambdaHandler which runs an OpenAPILambda
-struct OpenAPILambdaHandler<L: OpenAPILambda> {
+public struct OpenAPILambdaHandler<OALS: OpenAPILambdaService>: Sendable {
 
     private let router: OpenAPILambdaRouter
     private let transport: OpenAPILambdaTransport
-    private let lambda: L
+    private let openAPIService: OALS
 
     /// the input type for this Lambda handler (received from the `OpenAPILambda`)
-    public typealias Event = L.Event
+    public typealias Event = OALS.Event
 
     /// the output type for this Lambda handler (received from the `OpenAPILambda`)
-    public typealias Output = L.Output
+    public typealias Output = OALS.Output
 
     /// Initialize `OpenAPILambdaHandler`.
     ///
@@ -38,7 +38,23 @@ struct OpenAPILambdaHandler<L: OpenAPILambda> {
     init() throws {
         self.router = TrieRouter()
         self.transport = OpenAPILambdaTransport(router: self.router)
-        self.lambda = try .init(transport: self.transport)
+
+        // decouple the OpenAPILambda creation from the registration of teh transport
+        // this allows users to provide their own overloaded init() function to inject dependencies.
+        self.openAPIService = OALS()
+        try self.openAPIService.register(transport: self.transport)
+    }
+
+    /// Initialize an `OpenAPILambdaHandler` with your own `OpenAPILambda` object.
+    ///
+    /// Use this function when you need to inject dependencies in your OpenAPILambda
+    /// - Parameters:
+    ///   - lambda: The `OpenAPILambda` instance to use.
+    public init(service: OALS) throws {
+        self.router = TrieRouter()
+        self.transport = OpenAPILambdaTransport(router: self.router)
+        self.openAPIService = service
+        try self.openAPIService.register(transport: self.transport)
     }
 
     /// The Lambda handling method.
@@ -49,14 +65,14 @@ struct OpenAPILambdaHandler<L: OpenAPILambda> {
     ///     - context: Runtime ``LambdaContext``.
     ///
     /// - Returns: A Lambda result ot type `Output`.
-    func handler(event: L.Event, context: LambdaContext) async throws -> L.Output {
+    public func handler(event: OALS.Event, context: LambdaContext) async throws -> OALS.Output {
 
         // by default returns HTTP 500
         var lambdaResponse: OpenAPILambdaResponse = (HTTPResponse(status: .internalServerError), "unknown error")
 
         do {
             // convert Lambda event source to OpenAPILambdaRequest
-            let request = try lambda.request(context: context, from: event)
+            let request = try openAPIService.request(context: context, from: event)
 
             // route the request to find the handlers and extract the paramaters
             let (handler, parameters) = try router.route(method: request.0.method, path: request.0.path!)
@@ -105,6 +121,6 @@ struct OpenAPILambdaHandler<L: OpenAPILambda> {
         }
 
         // transform the OpenAPILambdaResponse to the Lambda Output
-        return lambda.output(from: lambdaResponse)
+        return openAPIService.output(from: lambdaResponse)
     }
 }

Sources/OpenAPILambdaTransport.swift

@@ -30,16 +30,20 @@ public typealias OpenAPILambdaResponse = (HTTPResponse, String?)
 public typealias OpenAPILambdaRequestParameters = [String: Substring]
 
 /// an OpenAPI handler
-public typealias OpenAPIHandler = (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
+public typealias OpenAPIHandler = @Sendable (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
     HTTPResponse, HTTPBody?
 )
 
 /// Lambda Transport for OpenAPI generator
-public struct OpenAPILambdaTransport: ServerTransport {
+public struct OpenAPILambdaTransport: ServerTransport, Sendable {
 
+    /// The router for the OpenAPILambdaTransport
+    /// Use this router to register your OpenAPI handlers
+    /// and add your own route, such as /health
     public let router: OpenAPILambdaRouter
 
     /// Create a `OpenAPILambdaTransport` with the given `OpenAPILambdaRouter`
+    /// - Parameter router: The router to use for the transport.
     init(router: OpenAPILambdaRouter) { self.router = router }
 
     /// Registers an HTTP operation handler at the provided path and method.

Sources/Router/OpenAPILambdaRouter.swift

@@ -24,7 +24,7 @@ public enum OpenAPILambdaRouterError: Error {
 }
 
 /// A router API
-public protocol OpenAPILambdaRouter {
+public protocol OpenAPILambdaRouter: Sendable {
     /// add a route for a given HTTP method and path and associate a handler
     func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws
 

Sources/Router/OpenAPILambdaRouterTrie.swift

@@ -13,20 +13,25 @@
 //
 //===----------------------------------------------------------------------===//
 import HTTPTypes
+import Synchronization
 
 /// A Trie router implementation
-struct TrieRouter: OpenAPILambdaRouter {
-    private let uriPath: URIPathCollection = URIPath()
+final class TrieRouter: OpenAPILambdaRouter {
+    private let uriPath = Mutex<any URIPathCollection>(URIPath())
 
     /// add a route for a given HTTP method and path and associate a handler
     func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws {
-        try uriPath.add(method: method, path: path, handler: handler)
+        try self.uriPath.withLock { @Sendable in
+            try $0.add(method: method, path: path, handler: handler)
+        }
     }
 
     /// Retrieve the handler and path parameter for a given HTTP method and path
     func route(method: HTTPRequest.Method, path: String) throws -> (
         OpenAPIHandler, OpenAPILambdaRequestParameters
-    ) { try uriPath.find(method: method, path: path) }
+    ) {
+        try self.uriPath.withLock { try $0.find(method: method, path: path) }
+    }
 }
 
 enum URIPathCollectionError: Error {