- Refactoring NIO Lambda Handlers Implementation

- Add documentation

Author: Andrea-Scuderi

Sources/LambdaSwiftSprinterNioPlugin/NIOLambdaHandler.swift

@@ -18,11 +18,229 @@ import NIOHTTP1
 import NIOFoundationCompat
 import LambdaSwiftSprinter
 
-public typealias AsyncDictionaryNIOLambda = ([String: Any], Context, @escaping (DictionaryResult) -> Void) -> Void
+/**
+ `SyncCodableNIOLambda<Event: Decodable, Response: Encodable>` lambda handler typealias.
+ 
+ - Usage example:
+ 
+ ```
+ import AsyncHTTPClient
+ import Foundation
+ #if canImport(FoundationNetworking)
+     import FoundationNetworking
+ #endif
+ import LambdaSwiftSprinter
+ import LambdaSwiftSprinterNioPlugin
+ import Logging
+ import NIO
+ import NIOFoundationCompat
+ 
+ struct Event: Codable {
+     let url: String
+ }
+
+ struct Response: Codable {
+     let url: String
+     let content: String
+ }
+ 
+ let syncCodableNIOLambda: SyncCodableNIOLambda<Event, Response> = { (event, context) throws -> EventLoopFuture<Response> in
+     
+     let request = try HTTPClient.Request(url: event.url)
+     let future = httpClient.execute(request: request, deadline: nil)
+         .flatMapThrowing { (response) throws -> String in
+                 guard let body = response.body,
+                     let value = body.getString(at: 0, length: body.readableBytes) else {
+                         throw SprinterError.invalidJSON
+             }
+             return value
+         }.map { content -> Response in
+             return Response(url: event.url, content: content)
+         }
+     return future
+ }
+ do {
+     let sprinter = try SprinterNIO()
+     sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+     
+     try sprinter.run()
+ } catch {
+     //log the error
+ }
+ ```
+*/
+public typealias SyncCodableNIOLambda<Event: Decodable, Response: Encodable> = (Event, Context) throws -> EventLoopFuture<Response>
+
+/**
+ `SyncDictionaryNIOLambda` lambda handler typealias.
+
+ - Usage example:
+ 
+ ```
+ import AsyncHTTPClient
+ import Foundation
+ #if canImport(FoundationNetworking)
+     import FoundationNetworking
+ #endif
+ import LambdaSwiftSprinter
+ import LambdaSwiftSprinterNioPlugin
+ import Logging
+ import NIO
+ import NIOFoundationCompat
+ 
+ enum MyError: Error {
+     case invalidParameters
+ }
+ 
+ let syncDictionaryNIOLambda: SyncDictionaryNIOLambda = { (event, context) throws -> EventLoopFuture<[String: Any]> in
+
+     guard let url = event["url"] as? String else {
+         throw MyError.invalidParameters
+     }
+
+     let request = try HTTPClient.Request(url: url)
+     let future = httpClient.execute(request: request, deadline: nil)
+         .flatMapThrowing { (response) throws -> String in
+             guard let body = response.body,
+                 let value = body.getString(at: 0, length: body.readableBytes) else {
+                     throw SprinterError.invalidJSON
+             }
+             return value
+         }.map { content -> [String: Any] in
+             return ["url": url,
+                     "content": content]
+         }
+     return future
+ }
+ do {
+     let sprinter = try SprinterNIO()
+     sprinter.register(handler: "getHttps", lambda: syncDictionaryNIOLambda)
+     
+     try sprinter.run()
+ } catch {
+     //log the error
+ }
+ ```
+*/
+public typealias SyncDictionaryNIOLambda = ([String: Any], Context) throws -> EventLoopFuture<[String: Any]>
+
+
+/**
+ `AsyncCodableNIOLambda<Event: Decodable, Response: Encodable>` lambda handler typealias.
+ 
+ - Parameter
+
+ - Usage example:
+ 
+ ```
+ import AsyncHTTPClient
+ import Foundation
+ #if canImport(FoundationNetworking)
+     import FoundationNetworking
+ #endif
+ import LambdaSwiftSprinter
+ import LambdaSwiftSprinterNioPlugin
+ import Logging
+ import NIO
+ import NIOFoundationCompat
+ 
+ struct Event: Codable {
+     let url: String
+ }
+
+ struct Response: Codable {
+     let url: String
+     let content: String
+ }
+ 
+ let asyncCodableNIOLambda: AsyncCodableNIOLambda<Event, Response> = { (event, context, completion) -> Void in
+     do {
+         let request = try HTTPClient.Request(url: event.url)
+         let reponse: Response = try httpClient.execute(request: request, deadline: nil)
+             .flatMapThrowing { (response) throws -> String in
+                 guard let body = response.body,
+                     let value = body.getString(at: 0, length: body.readableBytes) else {
+                         throw SprinterError.invalidJSON
+                 }
+                 return value
+         }.map { content -> Response in
+             return Response(url: event.url, content: content)
+         }
+         .wait()
+         completion(.success(reponse))
+     } catch {
+         completion(.failure(error))
+     }
+ }
+ do {
+     let sprinter = try SprinterNIO()
+     sprinter.register(handler: "getHttps", lambda: asyncCodableNIOLambda)
+     
+     try sprinter.run()
+ } catch {
+     //log the error
+ }
+ ```
+*/
 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>
+
+/**
+ `AsyncDictionaryNIOLambda` lambda handler typealias.
+
+ - Usage example:
+ 
+ ```
+ import AsyncHTTPClient
+ import Foundation
+ #if canImport(FoundationNetworking)
+     import FoundationNetworking
+ #endif
+ import LambdaSwiftSprinter
+ import LambdaSwiftSprinterNioPlugin
+ import Logging
+ import NIO
+ import NIOFoundationCompat
+ 
+ enum MyError: Error {
+     case invalidParameters
+ }
+ 
+ let asynchDictionayNIOLambda: AsyncDictionaryNIOLambda = { (event, context, completion) -> Void in
+     guard let url = event["url"] as? String else {
+         completion(.failure(MyError.invalidParameters))
+         return
+     }
+     do {
+         let request = try HTTPClient.Request(url: url)
+         let dictionary: [String: Any] = try httpClient.execute(request: request, deadline: nil)
+             .flatMapThrowing { (response) throws -> String in
+                 guard let body = response.body,
+                     let value = body.getString(at: 0, length: body.readableBytes) else {
+                         throw SprinterError.invalidJSON
+                 }
+                 return value
+         }.map { content -> [String: Any] in
+             return ["url": url,
+                     "content": content]
+         }
+         .wait()
+         completion(.success(dictionary))
+     } catch {
+         completion(.failure(error))
+     }
+ }
+ do {
+     let sprinter = try SprinterNIO()
+     sprinter.register(handler: "getHttps", lambda: asynchDictionayNIOLambda)
+     
+     try sprinter.run()
+ } catch {
+     //log the error
+ }
+ ```
+*/
+public typealias AsyncDictionaryNIOLambda = ([String: Any], Context, @escaping (DictionaryResult) -> Void) -> Void
 
 public protocol SyncNIOLambdaHandler: LambdaHandler {
 
@@ -70,7 +288,7 @@ public extension AsyncNIOLambdaHandler {
 
 struct CodableSyncNIOLambdaHandler<Event: Decodable, Response: Encodable>: SyncNIOLambdaHandler {
 
-    let handlerFunction: (Event, Context) -> EventLoopFuture<Response>
+    let handlerFunction: (Event, Context) throws -> EventLoopFuture<Response>
 
     func handler(event: Data, context: Context) -> EventLoopFuture<Data> {
 
@@ -115,16 +333,19 @@ struct CodableAsyncNIOLambdaHandler<Event: Decodable, Response: Encodable>: Asyn
 
 struct DictionarySyncNIOLambdaHandler: SyncNIOLambdaHandler {
 
-    let completionHandler: ([String: Any], Context) throws -> [String: Any]
+    let completionHandler: ([String: Any], Context) throws -> EventLoopFuture<[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)
+            .flatMapThrowing{ (dictionary) -> Data in
+                return try Data(jsonObject: dictionary)
+            }
+            .wait()
+            promise.succeed(output)
         } catch {
             promise.fail(error)
         }

Tests/LambdaSwiftSprinterNioPluginTests/NIOLambdaHandlerTests.swift

@@ -89,8 +89,11 @@ final class NIOLambdaHandlerTests: XCTestCase {
 
     func testDictionarySyncNIOLambdaHandler() {
         // When valid Data and valid completionHandler
-        let lambda = DictionarySyncNIOLambdaHandler { (dictionary, _) -> [String: Any] in
-            dictionary
+        let lambda = DictionarySyncNIOLambdaHandler { (dictionary, _) -> EventLoopFuture<[String: Any]> in
+            let eventloop = httpClient.eventLoopGroup.next()
+            let promise = eventloop.makePromise(of: [String: Any].self)
+            promise.succeed(dictionary)
+            return promise.futureResult
         }
         let result = try? lambda.handler(event: validData,
             context: validContext).wait()
@@ -101,7 +104,7 @@ final class NIOLambdaHandlerTests: XCTestCase {
             context: validContext).wait())
 
         // When valid Data and invalid completionHandler
-        let lambda2 = DictionarySyncNIOLambdaHandler { (_, _) -> [String: Any] in
+        let lambda2 = DictionarySyncNIOLambdaHandler { (_, _) -> EventLoopFuture<[String: Any]> in
             throw ErrorMock.someError
         }
 

Tests/LambdaSwiftSprinterNioPluginTests/SprinterNIOTests.swift

@@ -57,8 +57,11 @@ final class SprinterNIOTests: XCTestCase {
                            "_HANDLER": "Lambda.handler"]
         let sprinter = try? Sprinter<LambdaApiNIO>(environment: environment)
 
-        let completion: SyncDictionaryNIOLambda = { (_, _) -> [String: Any] in
-            ["": ""]
+        let completion: SyncDictionaryNIOLambda = { (_, _) -> EventLoopFuture<[String: Any]> in
+            let eventloop = httpClient.eventLoopGroup.next()
+            let promise = eventloop.makePromise(of: [String: Any].self)
+            promise.succeed(["":""])
+            return promise.futureResult
         }
         sprinter?.register(handler: "handler", lambda: completion)