Fix Documentation and README for S3Test and HTTPSRequest

Author: Andrea-Scuderi

Examples/HTTPSRequest/README.md

@@ -10,9 +10,14 @@ Define an Event and a Response as Codable.
 ```swift
 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
@@ -24,35 +29,27 @@ struct Response: Codable {
 }
 ```
 
-Use this code to allow the conversion of a `ByteBuffer` to `Data`
-```swift
-extension Array where Element == UInt8 {
-    var data: Data {
-        return Data(self)
-    }
-}
-```
-
 Add a loger:
 ```swift
 let logger = Logger(label: "AWS.Lambda.HTTPSRequest")
 ```
 
 Define the lambda:
 ```swift
-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).wait()
-
-    guard let body = response.body,
-        let buffer = body.getBytes(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)
+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
 }
 ```
 
@@ -64,10 +61,11 @@ Then use this boilerplate code to run the lambda:
 ```swift
 do {
     let sprinter = try SprinterNIO()
-    sprinter.register(handler: "getHttps", lambda: lambda)
+    sprinter.register(handler: "getHttps", lambda: syncCodableNIOLambda)
+    
     try sprinter.run()
 } catch {
-    logger.error(String(describing: error))
+    logger.error("\(String(describing: error))")
 }
 ```
 

Examples/HTTPSRequest/Sources/HTTPSRequest/main.swift

@@ -170,7 +170,7 @@ let asyncCodableNIOLambda: AsyncCodableNIOLambda<Event, Response> = { (event, co
 }
 
 /**
- Deprecated style of implementing the lambda using the NIO plugin.
+ Deprecated style of implementing the lambda using the core framework.
 
  - The example has been left to keep the compatibility with the tutorial:
 
@@ -201,6 +201,8 @@ let lambda: SyncCodableLambda<Event, Response> = { (input, context) throws -> Re
     return Response(url: input.url, content: content)
 }
 
+
+/// The following code it's required to setup, register, run the lambda and log errors.
 do {
     let sprinter = try SprinterNIO()
     //Note amend this line in case if it's required to use a different lambda handler.

Examples/S3Test/README.md

@@ -17,9 +17,14 @@ To launch this code you need:
 Define an Event and a Response as Codable.
 ```swift
 import Foundation
-import LambdaSwiftSprinter
+#if canImport(FoundationNetworking)
+    import FoundationNetworking
+#endif
+import LambdaSwiftSprinterNioPlugin
 import Logging
 import S3
+import NIO
+import NIOFoundationCompat
 
 struct Bucket: Codable {
     let name: String
@@ -44,22 +49,20 @@ let logger = Logger(label: "AWS.Lambda.HTTPSRequest")
 
 define the lambda:
 ```swift
-let getObject: AsyncCodableLambda<Bucket, Response> = { event, _, completion in
-
+let getObject: SyncCodableNIOLambda<Bucket, Response> = { (event, context) throws -> EventLoopFuture<Response> in
+    
     let getObjectRequest = S3.GetObjectRequest(bucket: event.name, key: event.key)
-    do {
-        let response = try s3.getObject(getObjectRequest).wait()
-
-        guard let body = response.body else {
-            logger.info("Body is empty")
-            completion(.success(Response(value: "")))
-            return
+    let future = s3.getObject(getObjectRequest)
+        .flatMapThrowing { (response) throws -> String in
+            guard let body = response.body,
+                let value = String(data: body, encoding: .utf8) else {
+                return ""
+            }
+            return value
+        }.map { content -> Response in
+            return Response(value: content)
         }
-        let value = String(data: body, encoding: .utf8)
-        completion(.success(Response(value: value)))
-    } catch {
-        completion(.failure(error))
-    }
+    return future
 }
 ```
 
@@ -70,13 +73,12 @@ This lambda is synchronous, meaning that all the operation are performed on the
 Then use this boilerplate code to run the lambda:
 ```swift
 do {
-    let sprinter = try SprinterCURL()
+    let sprinter = try SprinterNIO()
     sprinter.register(handler: "getObject", lambda: getObject)
     try sprinter.run()
 } catch {
-    logger.error("error: \(error)")
+    logger.error("\(String(describing: error))")
 }
-
 ```
 
 This will initialize the Sprinter with a Sprinter based on NIO 2 library.

Examples/S3Test/Sources/S3Test/main.swift

@@ -35,6 +35,16 @@ let s3 = S3(region: .useast1)
 
 let logger = Logger(label: "AWS.Lambda.S3Test")
 
+/**
+ How to use the `SyncCodableNIOLambda<Bucket, Response>` lambda handler with S3.
+
+ - The code is used by this example.
+ - Make sure the handler is registered:
+ 
+ ```
+ sprinter.register(handler: "getObject", lambda: getObject)
+ ```
+*/
 let getObject: SyncCodableNIOLambda<Bucket, Response> = { (event, context) throws -> EventLoopFuture<Response> in
 
     let getObjectRequest = S3.GetObjectRequest(bucket: event.name, key: event.key)
@@ -51,24 +61,38 @@ let getObject: SyncCodableNIOLambda<Bucket, Response> = { (event, context) throw
     return future
 }
 
-//let getObject: AsyncCodableNIOLambda<Bucket, Response> = { event, _, completion in
-//
-//    let getObjectRequest = S3.GetObjectRequest(bucket: event.name, key: event.key)
-//    do {
-//        let response = try s3.getObject(getObjectRequest).wait()
-//
-//        guard let body = response.body else {
-//            logger.info("Body is empty")
-//            completion(.success(Response(value: "")))
-//            return
-//        }
-//        let value = String(data: body, encoding: .utf8)
-//        completion(.success(Response(value: value)))
-//    } catch {
-//        completion(.failure(error))
-//    }
-//}
+/**
+ How to use the `AsyncCodableNIOLambda<Bucket, Response>` lambda handler with S3.
+
+ - 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: "getObject", lambda: getObject)
+ sprinter.register(handler: "getObjectAsync", lambda: getObjectAsync)
+ 
+ ```
+*/
+let getObjectAsync: AsyncCodableNIOLambda<Bucket, Response> = { event, _, completion in
+
+    let getObjectRequest = S3.GetObjectRequest(bucket: event.name, key: event.key)
+    do {
+        let response = try s3.getObject(getObjectRequest).wait()
+
+        guard let body = response.body else {
+            logger.info("Body is empty")
+            completion(.success(Response(value: "")))
+            return
+        }
+        let value = String(data: body, encoding: .utf8)
+        completion(.success(Response(value: value)))
+    } catch {
+        completion(.failure(error))
+    }
+}
 
+/// The following code it's required to setup, register, run the lambda and log errors.
 do {
     let sprinter = try SprinterNIO()
     sprinter.register(handler: "getObject", lambda: getObject)