wip

Author: sebsto

Examples/quoteapi/Sources/QuoteAPI/QuoteService.swift

@@ -28,7 +28,7 @@ struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi {
     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()
 
         // =============================
 
@@ -62,18 +62,17 @@ struct QuoteServiceImpl: APIProtocol, OpenAPILambdaHttpApi {
         // 3. create the lambda handler and pass the instance to its initializer
         // 4. create the lambda runtime and pass the handler to its initializer
 
-        // let openAPIService = QuoteServiceImpl(i: 42) // 2.
-        // let lambda = try OpenAPILambdaHandler(service: openAPIService) // 3.
-        // let lambdaRuntime = LambdaRuntime(body: lambda.handler) // 4.
-        // try await lambdaRuntime.run()
+        let openAPIService = QuoteServiceImpl(i: 42) // 2.
+        let lambda = try OpenAPILambdaHandler(withService: openAPIService) // 3.
+        let lambdaRuntime = LambdaRuntime(body: lambda.handle) // 4.
+        try await lambdaRuntime.run()
     }
 
     // example of dependency injection when using a custom initializer
-    // let i: Int
-    // init(i: Int) { // 1.
-    //     self.i = i
-    // }
-    // init() { self.i = 0 } // to comply with protocol
+    let i: Int
+    init(i: Int) { // 1.
+        self.i = i
+    }
 
     func getQuote(_ input: Operations.getQuote.Input) async throws -> Operations.getQuote.Output {
 

Sources/OpenAPILambda.swift

@@ -32,28 +32,16 @@ public struct OpenAPILambdaHandler<OALS: OpenAPILambdaService>: LambdaHandler {
 
     /// Initialize `OpenAPILambdaHandler`.
     ///
-    /// Create application, set it up and create `OpenAPILambda` from application and create responder
+    /// This initializer decouples the OpenAPILambdaService creation from the registration of the transport
+    /// this allows users to control the lifecycle of their service and to inject dependencies.
+    /// 
     /// - Parameters
-    ///   - context: Lambda initialization context
-    init() throws {
+    ///   - withService: The OpenAPI Lambda service to bind to this Lambda handler function
+    public init(withService openAPILambdaService: OALS) throws {
         self.router = TrieRouter()
         self.transport = OpenAPILambdaTransport(router: self.router)
 
-        // 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
+        self.openAPIService = openAPILambdaService
         try self.openAPIService.register(transport: self.transport)
     }
 

Sources/OpenAPILambdaHandler.swift

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift OpenAPI Lambda open source project
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates
+//                    and the Swift OpenAPI Lambda project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift OpenAPI Lambda project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+import Foundation
+import AWSLambdaRuntime
+import Logging
+import OpenAPIRuntime
+import HTTPTypes
+
+/// A Lambda function implemented with a OpenAPI server (implementing `APIProtocol` from Swift OpenAPIRuntime)
+public protocol OpenAPILambdaService: Sendable {
+
+    associatedtype Event: Decodable, Sendable
+    associatedtype Output: Encodable, Sendable
+
+    /// Injects the transport.
+    ///
+    /// 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
+    ///   - from: Event
+    func request(context: LambdaContext, from: Event) throws -> OpenAPILambdaRequest
+
+    /// Convert from `OpenAPILambdaResponse` to `Output` type
+    /// - Parameter from: response from OpenAPIRuntime
+    func output(from: OpenAPILambdaResponse) -> Output
+}
+
+// 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 makeHandler() throws -> OpenAPILambdaHandler<Self> {
+//         try OpenAPILambdaHandler<Self>()
+//     }
+
+//     /// Start the Lambda Runtime with the Lambda handler function for this OpenAPI Lambda implementation with a custom logger,
+//     /// 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: "OpenAPILambdaService")
+
+//         let handler = LambdaCodableAdapter(
+//             encoder: JSONEncoder(),
+//             decoder: JSONDecoder(),
+//             handler: LambdaHandlerAdapter(handler: try Self.makeHandler())
+//         )
+
+//         let lambdaRuntime = LambdaRuntime(handler: handler, logger: _logger)
+//         try await lambdaRuntime.run()
+//     }
+// }