PR review

Author: fabianfett

Package.swift

@@ -15,7 +15,7 @@ let package = Package(
         .library(name: "AWSLambdaTesting", targets: ["AWSLambdaTesting"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.17.0")),
+        .package(url: "https://github.com/apple/swift-nio.git", .branch("main")),
         .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.0.0")),
         .package(url: "https://github.com/swift-server/swift-backtrace.git", .upToNextMajor(from: "1.1.0")),
     ],
@@ -29,6 +29,7 @@ let package = Package(
             .product(name: "Logging", package: "swift-log"),
             .product(name: "Backtrace", package: "swift-backtrace"),
             .product(name: "NIOHTTP1", package: "swift-nio"),
+            .product(name: "_NIOConcurrency", package: "swift-nio")
         ]),
         .testTarget(name: "AWSLambdaRuntimeCoreTests", dependencies: [
             .byName(name: "AWSLambdaRuntimeCore"),

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -82,29 +82,23 @@ internal struct CodableVoidClosureWrapper<In: Decodable>: LambdaHandler {
 
 #if compiler(>=5.5) && $AsyncAwait
 extension Lambda {
-    /// An async Lambda Closure that takes a `In: Decodable` and returns an `Out: Encodable`
-    public typealias CodableAsyncClosure<In: Decodable, Out: Encodable> = (Lambda.Context, In) async throws -> Out
-
     /// Run a Lambda defined by implementing the `CodableAsyncClosure` function.
     ///
     /// - parameters:
     ///     - closure: `CodableAsyncClosure` based Lambda.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run<In: Decodable, Out: Encodable>(_ closure: @escaping CodableAsyncClosure<In, Out>) {
+    public static func run<In: Decodable, Out: Encodable>(_ closure: @escaping (In, Lambda.Context) async throws -> Out) {
         self.run(CodableAsyncWrapper(closure))
     }
 
-    /// An asynchronous Lambda Closure that takes a `In: Decodable` and returns nothing.
-    public typealias CodableVoidAsyncClosure<In: Decodable> = (Lambda.Context, In) async throws -> Void
-
     /// Run a Lambda defined by implementing the `CodableVoidAsyncClosure` function.
     ///
     /// - parameters:
     ///     - closure: `CodableVoidAsyncClosure` based Lambda.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run<In: Decodable>(_ closure: @escaping CodableVoidAsyncClosure<In>) {
+    public static func run<In: Decodable>(_ closure: @escaping (In, Lambda.Context) async throws -> Void) {
         self.run(CodableVoidAsyncWrapper(closure))
     }
 }
@@ -113,29 +107,29 @@ internal struct CodableAsyncWrapper<In: Decodable, Out: Encodable>: AsyncLambdaH
     typealias In = In
     typealias Out = Out
 
-    private let closure: Lambda.CodableAsyncClosure<In, Out>
+    private let closure: (In, Lambda.Context) async throws -> Out
 
-    init(_ closure: @escaping Lambda.CodableAsyncClosure<In, Out>) {
+    init(_ closure: @escaping (In, Lambda.Context) async throws -> Out) {
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, event: In) async throws -> Out {
-        try await self.closure(context, event)
+    func handle(event: In, context: Lambda.Context) async throws -> Out {
+        try await self.closure(event, context)
     }
 }
 
 internal struct CodableVoidAsyncWrapper<In: Decodable>: AsyncLambdaHandler {
     typealias In = In
     typealias Out = Void
 
-    private let closure: Lambda.CodableVoidAsyncClosure<In>
+    private let closure: (In, Lambda.Context) async throws -> Void
 
-    init(_ closure: @escaping Lambda.CodableVoidAsyncClosure<In>) {
+    init(_ closure: @escaping (In, Lambda.Context) async throws -> Void) {
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, event: In) async throws {
-        try await self.closure(context, event)
+    func handle(event: In, context: Lambda.Context) async throws {
+        try await self.closure(event, context)
     }
 }
 #endif

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -21,6 +21,7 @@ import Darwin.C
 import Backtrace
 import Logging
 import NIO
+import _NIOConcurrency
 
 public enum Lambda {
     public typealias Handler = ByteBufferLambdaHandler
@@ -59,17 +60,10 @@ public enum Lambda {
     #if compiler(>=5.5) && $AsyncAwait
     public static func run(_ factory: @escaping (InitializationContext) async throws -> Handler) {
         self.run { context -> EventLoopFuture<Handler> in
-            @asyncHandler func _createLambda(_ context: InitializationContext, promise: EventLoopPromise<Handler>) {
-                do {
-                    let handler = try await factory(context)
-                    promise.succeed(handler)
-                } catch {
-                    promise.fail(error)
-                }
-            }
-
             let promise = context.eventLoop.makePromise(of: Handler.self)
-            _createLambda(context, promise: promise)
+            promise.completeWithAsync {
+                try await factory(context)
+            }
             return promise.futureResult
         }
     }

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -92,27 +92,20 @@ public protocol AsyncLambdaHandler: EventLoopLambdaHandler {
     /// Concrete Lambda handlers implement this method to provide the Lambda functionality.
     ///
     /// - parameters:
-    ///     - context: Runtime `Context`.
     ///     - event: Event of type `In` representing the event or request.
+    ///     - context: Runtime `Context`.
     ///
     /// - Returns: A Lambda result ot type `Out`.
-    func handle(context: Lambda.Context, event: In) async throws -> Out
+    func handle(event: In, context: Lambda.Context) async throws -> Out
 }
 
 extension AsyncLambdaHandler {
     public func handle(context: Lambda.Context, event: In) -> EventLoopFuture<Out> {
         let promise = context.eventLoop.makePromise(of: Out.self)
-        self._run(context: context, event: event, promise: promise)
-        return promise.futureResult
-    }
-
-    @asyncHandler private func _run(context: Lambda.Context, event: In, promise: EventLoopPromise<Out>) {
-        do {
-            let result = try await self.handle(context: context, event: event)
-            promise.succeed(result)
-        } catch {
-            promise.fail(error)
+        promise.completeWithAsync {
+            try await self.handle(event: event, context: context)
         }
+        return promise.futureResult
     }
 }
 #endif

Tests/AWSLambdaRuntimeCoreTests/LambdaHandlerTest.swift

@@ -92,7 +92,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = String
 
-            func handle(context: Lambda.Context, event: String) async throws -> String {
+            func handle(event: String, context: Lambda.Context) async throws -> String {
                 event
             }
         }
@@ -112,7 +112,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = Void
 
-            func handle(context: Lambda.Context, event: String) async throws {}
+            func handle(event: String, context: Lambda.Context) async throws {}
         }
 
         let maxTimes = Int.random(in: 1 ... 10)
@@ -130,7 +130,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = String
 
-            func handle(context: Lambda.Context, event: String) async throws -> String {
+            func handle(event: String, context: Lambda.Context) async throws -> String {
                 throw TestError("boom")
             }
         }

Tests/AWSLambdaRuntimeTests/Lambda+CodeableTest.swift

@@ -69,7 +69,7 @@ class CodableLambdaTest: XCTestCase {
         var inputBuffer: ByteBuffer?
         var outputBuffer: ByteBuffer?
 
-        let closureWrapper = CodableVoidAsyncWrapper { (_, req: Request) in
+        let closureWrapper = CodableVoidAsyncWrapper { (req: Request, _) in
             XCTAssertEqual(request, req)
         }
 
@@ -84,7 +84,7 @@ class CodableLambdaTest: XCTestCase {
         var outputBuffer: ByteBuffer?
         var response: Response?
 
-        let closureWrapper = CodableAsyncWrapper { (_, req: Request) -> Response in
+        let closureWrapper = CodableAsyncWrapper { (req: Request, _) -> Response in
             XCTAssertEqual(req, request)
             return Response(requestId: req.requestId)
         }