FIX: HTTPSRequest example

TODO: UPDATE Package.swift

Author: Andrea-Scuderi

Examples/HTTPSRequest/Package.resolved

@@ -8,7 +8,7 @@ let package = Package(
     dependencies: [
         // Dependencies declare other packages that this package depends on.
         //.package(path: "../../../aws-lambda-swift-sprinter-nio-plugin"),
-        .package(url: "https://github.com/swift-sprinter/aws-lambda-swift-sprinter-nio-plugin", from: "1.0.0-alpha.2"),
+        .package(url: "https://github.com/swift-sprinter/aws-lambda-swift-sprinter-nio-plugin", from: "1.0.0-alpha.3"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
     ],
     targets: [

Examples/HTTPSRequest/Package.swift

@@ -20,6 +20,8 @@ import Foundation
 import LambdaSwiftSprinter
 import LambdaSwiftSprinterNioPlugin
 import Logging
+import NIO
+import NIOFoundationCompat
 
 struct Event: Codable {
     let url: String
@@ -30,32 +32,180 @@ struct Response: Codable {
     let content: String
 }
 
-extension Array where Element == UInt8 {
-    var data: Data {
-        return Data(self)
+let logger = Logger(label: "AWS.Lambda.HTTPSRequest")
+
+/**
+ How to use the `SyncCodableNIOLambda<Event, Response>` lambda handler.
+
+ - The code is used by this example.
+ - Make sure the handler is registered:
+ 
+ ```
+ sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+ ```
+*/
+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
+}
+
+enum MyError: Error {
+    case invalidParameters
+}
+
+/**
+ How to use the `SyncDictionaryNIOLambda` lambda handler.
+
+ - The code is unused.
+ - Make sure the handler is registered.
+ - If it's required by the lambda implementation, amend the following lines:
+ 
+ ```
+ //sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+ sprinter.register(handler: "getHttps", lambda: syncDictionaryNIOLambda)
+ 
+ ```
+*/
+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
 }
 
-let logger = Logger(label: "AWS.Lambda.HTTPSRequest")
+/**
+ How to use the `AsyncDictionaryNIOLambda` lambda handler.
 
-let lambda: SyncCodableLambda<Event, Response> = { (input, context) throws -> Response in
+ - The code is unused.
+ - Make sure the handler is registered.
+ - If it's required by the lambda implementation, amend the following lines:
+ 
+ ```
+ //sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+ sprinter.register(handler: "getHttps", lambda: asynchDictionayNIOLambda)
+ 
+ ```
+*/
+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))
+    }
+}
 
-    let request = try HTTPClient.Request(url: input.url)
-    let response = try httpClient.execute(request: request).wait()
+/**
+ How to use the `AsyncCodableNIOLambda<Event, Response>` lambda handler.
 
+ - The code is unused.
+ - Make sure the handler is registered.
+ - If it's required by the lambda implementation, amend the following lines:
+ 
+ ```
+ //sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+ sprinter.register(handler: "getHttps", lambda: asyncCodableNIOLambda)
+ 
+ ```
+*/
+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))
+    }
+}
+
+/**
+ Deprecated style of implementing the lambda using the NIO plugin.
+ 
+ - The example has been left to keep the compatibility with the tutorial:
+ 
+ [How to work with aws lambda in swift](https://medium.com/better-programming/how-to-work-with-aws-lambda-in-swift-28326c5cc765)
+ 
+ 
+ - The code is unused.
+ - Make sure the handler is registered.
+ - If it's required by the lambda implementation, amend the following lines:
+ 
+ ```
+ //sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+ sprinter.register(handler: "getHttps", lambda: lambda)
+ 
+ ```
+*/
+let lambda: SyncCodableLambda<Event, Response> = { (input, context) throws -> Response in
+    
+    let request = try HTTPClient.Request(url: input.url)
+    let response = try httpClient.execute(request: request, deadline: nil).wait()
+    
     guard let body = response.body,
-        let buffer = body.getBytes(at: 0, length: body.readableBytes) else {
-        throw SprinterError.invalidJSON
+        let data = body.getData(at: 0, length: body.readableBytes) else {
+            throw SprinterError.invalidJSON
     }
-    let data = Data(buffer)
     let content = String(data: data, encoding: .utf8) ?? ""
-
+    
     return Response(url: input.url, content: content)
 }
 
 do {
     let sprinter = try SprinterNIO()
-    sprinter.register(handler: "getHttps", lambda: lambda)
+    //Note amend this line in case if it's required to use a different lambda handler.
+    sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+    
     try sprinter.run()
 } catch {
     logger.error("\(String(describing: error))")