Add more lambda handlers using the NIO coding style

Author: Andrea-Scuderi

Sources/LambdaSwiftSprinterNioPlugin/LambdaApiNIO.swift

@@ -39,6 +39,7 @@ public var httpClient: HTTPClientProtocol = {
 }()
 
 public protocol HTTPClientProtocol: class {
+    var eventLoopGroup: EventLoopGroup { get }
     func get(url: String, deadline: NIODeadline?) -> EventLoopFuture<HTTPClient.Response>
     func post(url: String, body: HTTPClient.Body?, deadline: NIODeadline?)  -> EventLoopFuture<HTTPClient.Response>
     func execute(request: HTTPClient.Request, deadline: NIODeadline?) -> EventLoopFuture<HTTPClient.Response>
@@ -54,19 +55,28 @@ extension HTTPClient: HTTPClientProtocol {
 public class LambdaApiNIO: LambdaAPI {
 
     let urlBuilder: LambdaRuntimeAPIUrlBuilder
+    
+    private let _nextInvocationRequest: HTTPClient.Request
 
     /// Construct a `LambdaApiNIO` class.
     ///
     /// - parameters
     ///     - awsLambdaRuntimeAPI: AWS_LAMBDA_RUNTIME_API
     public required init(awsLambdaRuntimeAPI: String) throws {
         self.urlBuilder = try LambdaRuntimeAPIUrlBuilder(awsLambdaRuntimeAPI: awsLambdaRuntimeAPI)
+        self._nextInvocationRequest = try HTTPClient.Request(url: urlBuilder.nextInvocationURL(), method: .GET)
     }
 
+    /// Call the next invocation API to get the next event. The response body contains the event data. Response headers contain the `RequestID` and other information.
+    ///
+    /// - returns:
+    ///     - `(event: Data, responseHeaders: [AnyHashable: Any])` the event to process and the responseHeaders
+    /// - throws:
+    ///     - `invalidBuffer` if the body is empty or the buffer doesn't contain data.
+    ///     - `invalidResponse(HTTPResponseStatus)` if the HTTP response is not valid.
     public func getNextInvocation() throws -> (event: Data, responseHeaders: [AnyHashable: Any]) {
-        let request = try HTTPClient.Request(url: urlBuilder.nextInvocationURL(), method: .GET)
         let result = try httpClient.execute(
-            request: request,
+            request: _nextInvocationRequest,
             deadline: nil
         ).wait()
 
@@ -86,6 +96,13 @@ public class LambdaApiNIO: LambdaAPI {
         }
     }
 
+    /// Sends an invocation response to Lambda.
+    ///
+    /// - parameters:
+    ///     - requestId: Request ID
+    ///     - httpBody: data body.
+    /// - throws:
+    ///     - HttpClient errors
     public func postInvocationResponse(for requestId: String, httpBody: Data) throws {
         var request = try HTTPClient.Request(
             url: urlBuilder.invocationResponseURL(requestId: requestId),
@@ -98,6 +115,13 @@ public class LambdaApiNIO: LambdaAPI {
         ).wait()
     }
 
+    /// Sends an invocation error to Lambda.
+    ///
+    /// - parameters:
+    ///     - requestId: Request ID
+    ///     - error: error
+    /// - throws:
+    ///     - HttpClient errors
     public func postInvocationError(for requestId: String, error: Error) throws {
         let errorMessage = String(describing: error)
         let invocationError = InvocationError(errorMessage: errorMessage,
@@ -114,6 +138,12 @@ public class LambdaApiNIO: LambdaAPI {
         ).wait()
     }
 
+    /// Sends an initialization error to Lambda.
+    ///
+    /// - parameters:
+    ///     - error: error
+    /// - throws:
+    ///     - HttpClient errors
     public func postInitializationError(error: Error) throws {
         let errorMessage = String(describing: error)
         let invocationError = InvocationError(errorMessage: errorMessage,

Sources/LambdaSwiftSprinterNioPlugin/NIOLambdaHandler.swift

@@ -0,0 +1,182 @@
+//    Copyright 2019 (c) Andrea Scuderi - https://github.com/swift-sprinter
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+import Foundation
+import NIO
+import NIOHTTP1
+import NIOFoundationCompat
+import LambdaSwiftSprinter
+
+public typealias AsyncDictionaryNIOLambda = ([String: Any], Context, @escaping (DictionaryResult) -> Void) -> Void
+public typealias AsyncCodableNIOLambda<Event: Decodable, Response: Encodable> = (Event, Context, @escaping (Result<Response, Error>) -> Void) -> Void
+
+public typealias SyncDictionaryNIOLambda = ([String: Any], Context) throws -> [String: Any]
+public typealias SyncCodableNIOLambda<Event: Decodable, Response: Encodable> = (Event, Context) -> EventLoopFuture<Response>
+
+public protocol SyncNIOLambdaHandler: LambdaHandler {
+    
+    func handler(event: Data, context: Context) -> EventLoopFuture<Data>
+}
+
+public extension SyncNIOLambdaHandler {
+    
+    func commonHandler(event: Data, context: Context) -> LambdaResult {
+        do {
+            let data = try handler(event: event, context: context).wait()
+            return .success(data)
+        } catch {
+            return .failure(error)
+        }
+    }
+}
+
+public protocol AsyncNIOLambdaHandler: LambdaHandler {
+    
+    func handler(event: Data, context: Context, completion: @escaping (LambdaResult) -> Void)
+}
+
+public extension AsyncNIOLambdaHandler {
+    func commonHandler(event: Data, context: Context) -> LambdaResult {
+        let eventLoop = httpClient.eventLoopGroup.next()
+        let promise = eventLoop.makePromise(of: LambdaResult.self)
+        handler(event: event, context: context) { result in
+            
+            switch result {
+                case .success(_):
+                    promise.succeed(result)
+                case .failure(let error):
+                    promise.fail(error)
+            }
+        }
+        do {
+            let result = try promise.futureResult.wait()
+            return result
+        } catch {
+            return .failure(error)
+        }
+    }
+}
+
+struct CodableSyncNIOLambdaHandler<Event: Decodable, Response: Encodable>: SyncNIOLambdaHandler {
+    
+    let handlerFunction: (Event, Context) -> EventLoopFuture<Response>
+
+    func handler(event: Data, context: Context) -> EventLoopFuture<Data> {
+        
+        let eventLoop = httpClient.eventLoopGroup.next()
+        let promise = eventLoop.makePromise(of: Data.self)
+        do {
+            let eventObj = try event.decode() as Event
+            let responseObj = try handlerFunction(eventObj, context).wait()
+            let response = try Data(from: responseObj)
+            promise.succeed(response)
+        } catch {
+            promise.fail(error)
+        }
+        return promise.futureResult
+    }
+}
+
+struct CodableAsyncNIOLambdaHandler<Event: Decodable, Response: Encodable>: AsyncNIOLambdaHandler {
+    let handlerFunction: AsyncCodableLambda<Event, Response>
+
+    func handler(event: Data, context: Context, completion: @escaping (LambdaResult) -> Void) {
+        do {
+            let data = try event.decode() as Event
+            handlerFunction(data, context) { outputResult in
+                switch outputResult {
+                case .failure(let error):
+                    completion(.failure(error))
+                case .success(let outputDict):
+                    do {
+                        let outputData = try Data(from: outputDict)
+                        completion(.success(outputData))
+                    } catch {
+                        completion(.failure(error))
+                    }
+                }
+            }
+        } catch {
+            completion(.failure(error))
+        }
+    }
+}
+
+struct DictionarySyncNIOLambdaHandler: SyncNIOLambdaHandler {
+    
+    let completionHandler: ([String: Any], Context) throws -> [String: Any]
+    func handler(event: Data, context: Context) -> EventLoopFuture<Data> {
+        
+        let eventLoop = httpClient.eventLoopGroup.next()
+        let promise = eventLoop.makePromise(of: Data.self)
+        do {
+            let data = try event.jsonObject()
+            let output = try completionHandler(data, context)
+            let responseObj = try Data(jsonObject: output)
+            promise.succeed(responseObj)
+        } catch {
+            promise.fail(error)
+        }
+        return promise.futureResult
+    }
+}
+
+struct DictionaryAsyncNIOLambdaHandler: AsyncNIOLambdaHandler {
+    let completionHandler: AsyncDictionaryLambda
+
+    func handler(event: Data, context: Context, completion: @escaping (LambdaResult) -> Void) {
+        do {
+            let jsonDictionary = try event.jsonObject()
+            completionHandler(jsonDictionary, context) { outputResult in
+                switch outputResult {
+                case .failure(let error):
+                    completion(.failure(error))
+                case .success(let outputDict):
+                    do {
+                        let outputData = try Data(jsonObject: outputDict)
+                        completion(.success(outputData))
+                    } catch {
+                        completion(.failure(error))
+                    }
+                }
+            }
+        } catch {
+            completion(.failure(error))
+        }
+    }
+}
+
+public extension Sprinter where API == LambdaApiNIO {
+    func register(handler name: String, lambda: @escaping SyncDictionaryNIOLambda) {
+        let handler = DictionarySyncNIOLambdaHandler(completionHandler: lambda)
+        register(handler: name, lambda: handler)
+    }
+    
+    func register(handler name: String, lambda: @escaping AsyncDictionaryNIOLambda) {
+        let handler = DictionaryAsyncNIOLambdaHandler(completionHandler: lambda)
+        register(handler: name, lambda: handler)
+    }
+    
+    func register<Event: Decodable, Response: Encodable>(handler name: String,
+                                                         lambda: @escaping SyncCodableNIOLambda<Event, Response>) {
+        let handler = CodableSyncNIOLambdaHandler(handlerFunction: lambda)
+        register(handler: name, lambda: handler)
+    }
+    
+    func register<Event: Decodable, Response: Encodable>(handler name: String,
+                                                         lambda: @escaping AsyncCodableNIOLambda<Event, Response>) {
+        let handler = CodableAsyncNIOLambdaHandler(handlerFunction: lambda)
+        register(handler: name, lambda: handler)
+    }
+}

Sources/LambdaSwiftSprinterNioPlugin/Utils.swift

@@ -16,6 +16,7 @@ import Foundation
 import NIO
 import NIOHTTP1
 import NIOFoundationCompat
+import LambdaSwiftSprinter
 
 internal extension HTTPHeaders {
     var dictionary: [String: String] {
@@ -33,6 +34,24 @@ internal extension Data {
         let jsonEncoder = JSONEncoder()
         self = try jsonEncoder.encode(object)
     }
+    
+    func decode<T: Decodable>() throws -> T {
+        let jsonDecoder = JSONDecoder()
+        let input = try jsonDecoder.decode(T.self, from: self)
+        return input
+    }
+
+    func jsonObject() throws -> [String: Any] {
+        let jsonObject = try JSONSerialization.jsonObject(with: self)
+        guard let payload = jsonObject as? [String: Any] else {
+            throw SprinterError.invalidJSON
+        }
+        return payload
+    }
+
+    init(jsonObject: [String: Any]) throws {
+        self = try JSONSerialization.data(withJSONObject: jsonObject)
+    }
 
     var byteBuffer: ByteBuffer {
         var buffer = ByteBufferAllocator().buffer(capacity: self.count)

Tests/LambdaSwiftSprinterNioPluginTests/LambdaApiNIOTests.swift

@@ -21,7 +21,6 @@ import XCTest
 
 
 @testable import LambdaSwiftSprinterNioPlugin
-// FIXME: Add Unit test
 
 final class LambdaApiNIOTests: XCTestCase {
 
@@ -157,10 +156,10 @@ final class LambdaApiNIOTests: XCTestCase {
     }
 
     static var allTests = [
+           ("testGetNextInvocation", testGetNextInvocation),
         ("testInit", testInit),
-        ("testGetNextInvocation", testGetNextInvocation),
-        ("testPostInvocationResponse", testPostInvocationResponse),
-        ("testPostInvocationError", testPostInvocationError),
         ("testPostInitializationError", testPostInitializationError),
+        ("testPostInvocationError", testPostInvocationError),
+        ("testPostInvocationResponse", testPostInvocationResponse),
     ]
 }