remove unecessary sendable conformance

Author: sebsto

Sources/OpenAPILambda.swift

@@ -19,7 +19,7 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// A Lambda function implemented with a OpenAPI server (implementing `APIProtocol` from Swift OpenAPIRuntime)
-public protocol OpenAPILambda: Sendable {
+public protocol OpenAPILambda {
 
     associatedtype Event: Decodable
     associatedtype Output: Encodable
@@ -43,7 +43,7 @@ public protocol OpenAPILambda: Sendable {
 extension OpenAPILambda {
     /// Returns the Lambda handler function for this OpenAPI Lambda implementation.
     /// - Returns: A handler function that can be used with AWS Lambda Runtime
-    public static func handler() throws -> @Sendable (Event, LambdaContext) async throws -> Output {
+    public static func handler() throws -> (Event, LambdaContext) async throws -> Output {
         try OpenAPILambdaHandler<Self>().handler
     }
 

Sources/OpenAPILambdaHandler.swift

@@ -18,7 +18,7 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// Specialization of LambdaHandler which runs an OpenAPILambda
-struct OpenAPILambdaHandler<L: OpenAPILambda>: Sendable {
+struct OpenAPILambdaHandler<L: OpenAPILambda> {
 
     private let router: OpenAPILambdaRouter
     private let transport: OpenAPILambdaTransport
@@ -59,7 +59,7 @@ struct OpenAPILambdaHandler<L: OpenAPILambda>: Sendable {
             let request = try lambda.request(context: context, from: event)
 
             // route the request to find the handlers and extract the paramaters
-            let (handler, parameters) = try await router.route(method: request.0.method, path: request.0.path!)
+            let (handler, parameters) = try router.route(method: request.0.method, path: request.0.path!)
 
             // call the request handler (and extract the HTTPRequest and HTTPBody)
             let httpRequest = request.0

Sources/OpenAPILambdaTransport.swift

@@ -30,12 +30,12 @@ public typealias OpenAPILambdaResponse = (HTTPResponse, String?)
 public typealias OpenAPILambdaRequestParameters = [String: Substring]
 
 /// an OpenAPI handler
-public typealias OpenAPIHandler = @Sendable (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
+public typealias OpenAPIHandler = (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
     HTTPResponse, HTTPBody?
 )
 
 /// Lambda Transport for OpenAPI generator
-public struct OpenAPILambdaTransport: ServerTransport, Sendable {
+public struct OpenAPILambdaTransport: ServerTransport {
 
     private let router: OpenAPILambdaRouter
 
@@ -50,29 +50,6 @@ public struct OpenAPILambdaTransport: ServerTransport, Sendable {
     ///   - queryItemNames: The names of query items to be extracted
     ///   from the request URL that matches the provided HTTP operation.
     public func register(_ handler: @escaping OpenAPIHandler, method: HTTPRequest.Method, path: String) throws {
-
-        // call the actor-isolated `router.add()` function from a synchronous context
-        // because ServerTransport.resgister() is synchronous
-        let semaphore = DispatchSemaphore(value: 0)
-        let errorBox = Box<Error?>(nil)
-
-        Task { @Sendable in
-            do {
-                try await self.router.add(method: method, path: path, handler: handler)
-            }
-            catch {
-                errorBox.value = error
-            }
-            semaphore.signal()
-        }
-        semaphore.wait()
-        if let error = errorBox.value {
-            throw error
-        }
-    }
-
-    private final class Box<T>: @unchecked Sendable {
-        var value: T
-        init(_ value: T) { self.value = value }
+        try self.router.add(method: method, path: path, handler: handler)
     }
 }

Sources/Router/OpenAPILambdaRouter.swift

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

Sources/Router/OpenAPILambdaRouterNode.swift

@@ -22,7 +22,7 @@ import HTTPTypes
 /// - a path element (represented as a `String`),
 /// - a path parameter (represented as a `String`)
 /// - a handler, only for leaf nodes (represented as `OpenAPIHandler`)
-actor Node {
+final class Node {
     let value: NodeValue
     var children: [String: Node] = [:]
 
@@ -62,8 +62,8 @@ actor Node {
     /// - Throws:
     ///   - URIPathCollectionError.canNotAddChildToHandlerNode when trying to add a child to leaf node of type `.handler`
     ///   - URIPathCollectionError.canNotHaveMultipleParamChilds when trying to add multiple child node of type `.parameter`
-
     func add(pathElement: String) throws -> Node { try add(child: NodeValue.pathElement(pathElement)) }
+
     /// Convenience method to add a child node of type path parameter  to this node
     /// - Parameter:
     ///     - pathParameter: the name of a path parameter. A path parameter is a `{name}` usually found between `/` characters in the URI
@@ -72,8 +72,8 @@ actor Node {
     /// - Throws:
     ///   - URIPathCollectionError.canNotAddChildToHandlerNode when trying to add a child to leaf node of type `.handler`
     ///   - URIPathCollectionError.canNotHaveMultipleParamChilds when trying to add multiple child node of type `.parameter`
-
     func add(parameter: String) throws -> Node { try add(child: NodeValue.pathParameter(parameter)) }
+
     /// Convenience method to add a child node of type handler to this node
     /// - Parameter:
     ///     - handler: a function handler. A handler MUST be a leaf node (it has no children) and is of type `OpenAPIHandler`

Sources/Router/OpenAPILambdaRouterTrie.swift

@@ -19,25 +19,25 @@ struct TrieRouter: OpenAPILambdaRouter {
     private let uriPath: 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) async throws {
-        try await uriPath.add(method: method, path: path, handler: handler)
+    func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws {
+        try uriPath.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) async throws -> (
+    func route(method: HTTPRequest.Method, path: String) throws -> (
         OpenAPIHandler, OpenAPILambdaRequestParameters
-    ) { try await uriPath.find(method: method, path: path) }
+    ) { try uriPath.find(method: method, path: path) }
 }
 
 enum URIPathCollectionError: Error {
     case canNotAddChildToHandlerNode
     case canNotHaveMultipleParamChilds
 }
 
-protocol URIPathCollection: Sendable {
+protocol URIPathCollection {
     func root() -> Node
-    func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) async throws
-    func find(method: HTTPRequest.Method, path: String) async throws -> (OpenAPIHandler, OpenAPILambdaRequestParameters)
+    func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws
+    func find(method: HTTPRequest.Method, path: String) throws -> (OpenAPIHandler, OpenAPILambdaRequestParameters)
 }
 
 /// A Trie graph representation of an URI path + its handler
@@ -56,10 +56,10 @@ struct URIPath: URIPathCollection {
     ///     - method: the HTTP method to use as first node
     ///     - path: the full path as received from OpenAPI registration (including parameters encoded as {param name}
     ///     - handler: the OpenAPI handler to invoke for such path
-    func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) async throws {
+    func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws {
 
         // add or retrieve the HTTP method node
-        var node = try await root().add(httpMethod: method)
+        var node = try root().add(httpMethod: method)
 
         // add each path element as child nodes
         let pathComponents = path.split(separator: "/")
@@ -68,15 +68,15 @@ struct URIPath: URIPathCollection {
                 var comp = component
                 comp.removeFirst()
                 comp.removeLast()
-                node = try await node.add(parameter: String(comp))
+                node = try node.add(parameter: String(comp))
             }
             else {
-                node = try await node.add(pathElement: String(component))
+                node = try node.add(pathElement: String(component))
             }
         }
 
         // finally add the handler
-        _ = try await node.add(handler: handler)
+        _ = try node.add(handler: handler)
     }
 
     /// Navigate the tree to find the handler
@@ -91,13 +91,13 @@ struct URIPath: URIPathCollection {
     ///     - OpenAPILambdaRouterError.noRouteForPath when there is no handler in the graph for the given combination of HTTP method and path
     ///     - OpenAPILambdaRouterError.noRouteForMethod when there is no handler for that HTTP method
     ///     - OpenAPILambdaRouterError.noHandlerForPath when there is no handler as leaf node of the tree. This is a programming error and should not happen
-    func find(method: HTTPRequest.Method, path: String) async throws -> (OpenAPIHandler, OpenAPILambdaRequestParameters)
+    func find(method: HTTPRequest.Method, path: String) throws -> (OpenAPIHandler, OpenAPILambdaRequestParameters)
     {
         var parameters: OpenAPILambdaRequestParameters = [:]
         let root: Node = root()
 
         // first node is the HTTP Method
-        guard let nodeHTTP = await root.children[method.rawValue] else {
+        guard let nodeHTTP = root.children[method.rawValue] else {
             throw OpenAPILambdaRouterError.noRouteForMethod(method)
         }
 
@@ -106,14 +106,14 @@ struct URIPath: URIPathCollection {
         let pathComponents = path.prefix(while: { $0 != "?" }).split(separator: "/")
         var currentNode = nodeHTTP
         for component in pathComponents {
-            if let child = await currentNode.child(with: component) {
+            if let child = currentNode.child(with: component) {
                 // found a node with path element, continue to explore
                 currentNode = child
             }
             else {
                 // no path element for this component, maybe this component is a parameter value
                 // let's see if we have a child param node
-                if let child = await currentNode.parameterChild() {
+                if let child = currentNode.parameterChild() {
                     let paramName = child.value.asString!
 
                     //TODO: do not collect param when another child is a path with matching name ?
@@ -133,7 +133,7 @@ struct URIPath: URIPathCollection {
         }
 
         //at this stage, current node must have a handler child
-        guard let handlerNode = await currentNode.handlerChild() else {
+        guard let handlerNode = currentNode.handlerChild() else {
             throw OpenAPILambdaRouterError.noHandlerForPath(path)
         }