rename LambdaOpenAPITransport to OpenAPILambdaTransport for consistency

README.md

@@ -69,7 +69,7 @@ import OpenAPILambda // <-- 1. import this library
 @main // <-- 2. flag this struct as the executable target entrypoint
 struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi { // <-- 3. add the OpenAPILambdaHttpApi protocol 
 
-  init(transport: LambdaOpenAPITransport) throws { // <-- 4. add this constructor (don't remove the call to `registerHandlers(on:)`)
+  init(transport: OpenAPILambdaTransport) throws { // <-- 4. add this constructor (don't remove the call to `registerHandlers(on:)`)
     try self.registerHandlers(on: transport)
   }
 
@@ -247,7 +247,7 @@ import OpenAPILambda
 @main
 struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi {
 
-  init(transport: LambdaOpenAPITransport) throws {
+  init(transport: OpenAPILambdaTransport) throws {
     try self.registerHandlers(on: transport)
   }
 
@@ -494,7 +494,7 @@ Here is an example using `APIGatewayRequest` and `APIGatewayResponse`:
 struct QuoteServiceLambda: OpenAPILambda {
   typealias Event = APIGatewayRequest
   typealias Output = APIGatewayResponse
-  public init(transport: LambdaOpenAPITransport) throws {
+  public init(transport: OpenAPILambdaTransport) throws {
     let openAPIHandler = QuoteServiceImpl()
     try openAPIHandler.registerHandlers(on: transport)
   }
@@ -529,7 +529,7 @@ extension APIGatewayRequest {
     /// Return an `HTTPRequest.Method` for this `APIGatewayRequest`
     public func httpRequestMethod() throws -> HTTPRequest.Method {
         guard let method = HTTPRequest.Method(rawValue: self.httpMethod.rawValue) else {
-            throw LambdaOpenAPIHttpError.invalidMethod(self.httpMethod.rawValue)
+            throw OpenAPILambdaHttpError.invalidMethod(self.httpMethod.rawValue)
         }
         return method
     }

Sources/HttpApi/APIGatewayV2+HTTPRequest.swift

@@ -21,7 +21,7 @@ extension APIGatewayV2Request {
     /// Return an `HTTPRequest.Method` for this `APIGatewayV2Request`
     public func httpRequestMethod() throws -> HTTPRequest.Method {
         guard let method = HTTPRequest.Method(rawValue: self.context.http.method.rawValue) else {
-            throw LambdaOpenAPIHttpError.invalidMethod(self.context.http.method.rawValue)
+            throw OpenAPILambdaHttpError.invalidMethod(self.context.http.method.rawValue)
         }
         return method
     }

Sources/HttpApi/OpenAPILambdaHttpApi.swift

@@ -19,7 +19,7 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// The errors that can be generated
-public enum LambdaOpenAPIHttpError: Error {
+public enum OpenAPILambdaHttpError: Error {
     case invalidMethod(String)
 }
 

Sources/OpenAPILambda.swift

@@ -26,7 +26,7 @@ public protocol OpenAPILambda {
     /// Initialize application.
     ///
     /// This is where you create your OpenAPI service implementation and register the transport
-    init(transport: LambdaOpenAPITransport) throws
+    init(transport: OpenAPILambdaTransport) throws
 
     /// Convert from `Event` type to `OpenAPILambdaRequest`
     /// - Parameters:

Sources/OpenAPILambdaHandler.swift

@@ -33,7 +33,7 @@ public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
     ///   - context: Lambda initialization context
     public init(context: LambdaInitializationContext) throws {
         self.router = TrieRouter()
-        self.transport = LambdaOpenAPITransport(router: self.router)
+        self.transport = OpenAPILambdaTransport(router: self.router)
         self.lambda = try .init(transport: self.transport)
     }
 
@@ -67,7 +67,7 @@ public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
         return lambda.output(from: lambdaResponse)
     }
 
-    let router: LambdaOpenAPIRouter
-    let transport: LambdaOpenAPITransport
+    let router: OpenAPILambdaRouter
+    let transport: OpenAPILambdaTransport
     let lambda: L
 }

Sources/OpenAPILambdaTransport.swift

@@ -35,12 +35,12 @@ public typealias OpenAPIHandler = @Sendable (HTTPRequest, HTTPBody?, ServerReque
 )
 
 /// Lambda Transport for OpenAPI generator
-public struct LambdaOpenAPITransport: ServerTransport {
+public struct OpenAPILambdaTransport: ServerTransport {
 
-    private var router: LambdaOpenAPIRouter
+    private var router: OpenAPILambdaRouter
 
-    /// Create a `LambdaOpenAPITransport` with the given `LambdaOpenAPIRouter`
-    public init(router: LambdaOpenAPIRouter) { self.router = router }
+    /// Create a `OpenAPILambdaTransport` with the given `OpenAPILambdaRouter`
+    public init(router: OpenAPILambdaRouter) { self.router = router }
 
     /// Registers an HTTP operation handler at the provided path and method.
     /// - Parameters:

Sources/Router/OpenAPILambdaRouter.swift

@@ -17,14 +17,14 @@ import Foundation
 import HTTPTypes
 
 /// Errors returned by the router
-public enum LambdaOpenAPIRouterError: Error {
+public enum OpenAPILambdaRouterError: Error {
     case noRouteForPath(String)
     case noHandlerForPath(String)
     case noRouteForMethod(HTTPRequest.Method)
 }
 
 /// A router API
-public protocol LambdaOpenAPIRouter {
+public 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) throws
 

Sources/Router/OpenAPILambdaRouterTrie.swift

@@ -15,7 +15,7 @@
 import HTTPTypes
 
 /// A Trie router implementation
-public struct TrieRouter: LambdaOpenAPIRouter {
+public struct TrieRouter: OpenAPILambdaRouter {
     private let uriPath: URIPathCollection = URIPath()
 
     /// add a route for a given HTTP method and path and associate a handler
@@ -88,16 +88,16 @@ struct URIPath: URIPathCollection {
     ///     - the OpenAPIHandler for this path
     ///     - the OpenAI ServerRequestMetadata (a [String:String] with parameter names and their values
     /// - Throws:
-    ///     - LambdaOpenAPIRouterError.noRouteForPath when there is no handler in the graph for the given combination of HTTP method and path
-    ///     - LambdaOpenAPIRouterError.noRouteForMethod when there is no handler for that HTTP method
-    ///     - LambdaOpenAPIRouterError.noHandlerForPath when there is no handler as leaf node of the tree. This is a programming error and should not happen
+    ///     - 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) throws -> (OpenAPIHandler, OpenAPILambdaRequestParameters) {
         var parameters: OpenAPILambdaRequestParameters = [:]
         let root: Node = root()
 
         // first node is the HTTP Method
         guard let nodeHTTP = root.children[method.rawValue] else {
-            throw LambdaOpenAPIRouterError.noRouteForMethod(method)
+            throw OpenAPILambdaRouterError.noRouteForMethod(method)
         }
 
         // search for each path component.  If a component is not found, it might be a parameter
@@ -125,18 +125,18 @@ struct URIPath: URIPathCollection {
                     currentNode = child
                 }
                 else {
-                    throw LambdaOpenAPIRouterError.noRouteForPath(path)
+                    throw OpenAPILambdaRouterError.noRouteForPath(path)
                 }
             }
         }
 
         //at this stage, current node must have a handler child
         guard let handlerNode = currentNode.handlerChild() else {
-            throw LambdaOpenAPIRouterError.noHandlerForPath(path)
+            throw OpenAPILambdaRouterError.noHandlerForPath(path)
         }
 
         // did we found an handler ?
-        guard let handler = handlerNode.value.handler else { throw LambdaOpenAPIRouterError.noHandlerForPath(path) }
+        guard let handler = handlerNode.value.handler else { throw OpenAPILambdaRouterError.noHandlerForPath(path) }
         return (handler, parameters)
     }