Rename payload to event (#115)

Author: fabianfett

Examples/LambdaFunctions/Sources/APIGateway/main.swift

@@ -27,7 +27,7 @@ struct APIGatewayProxyLambda: EventLoopLambdaHandler {
     public typealias In = APIGateway.V2.Request
     public typealias Out = APIGateway.V2.Response
 
-    public func handle(context: Lambda.Context, payload: APIGateway.V2.Request) -> EventLoopFuture<APIGateway.V2.Response> {
+    public func handle(context: Lambda.Context, event: APIGateway.V2.Request) -> EventLoopFuture<APIGateway.V2.Response> {
         context.logger.debug("hello, api gateway!")
         return context.eventLoop.makeSucceededFuture(APIGateway.V2.Response(statusCode: .ok, body: "hello, world!"))
     }

Examples/LambdaFunctions/Sources/Benchmark/main.swift

@@ -25,7 +25,7 @@ struct BenchmarkHandler: EventLoopLambdaHandler {
     typealias In = String
     typealias Out = String
 
-    func handle(context: Lambda.Context, payload: String) -> EventLoopFuture<String> {
+    func handle(context: Lambda.Context, event: String) -> EventLoopFuture<String> {
         context.eventLoop.makeSucceededFuture("hello, world!")
     }
 }

Examples/LocalDebugging/README.md

@@ -23,8 +23,8 @@ Start with running the `MyLambda` target.
 * Set the `LOCAL_LAMBDA_SERVER_ENABLED` environment variable to `true` by editing the `MyLambda` scheme under `Run`.
 * Hit `Run`
 * Once it is up you should see a log message in the Xcode console saying
-`LocalLambdaServer started and listening on 127.0.0.1:7000, receiving payloads on /invoke`
-which means the local emulator is up and receiving traffic on port `7000` and expecting payloads on the `/invoke` endpoint.
+`LocalLambdaServer started and listening on 127.0.0.1:7000, receiving events on /invoke`
+which means the local emulator is up and receiving traffic on port `7000` and expecting events on the `/invoke` endpoint.
 
 Continue to run the `MyApp` target
 * Switch to the `MyApp` scheme and select a simulator destination.

Sources/AWSLambdaEvents/Cloudwatch.swift

@@ -14,7 +14,7 @@
 
 import struct Foundation.Date
 
-/// EventBridge has the same payloads/notification types as CloudWatch
+/// EventBridge has the same events/notification types as CloudWatch
 typealias EventBridge = Cloudwatch
 
 public protocol CloudwatchDetail: Decodable {
@@ -66,7 +66,7 @@ public enum Cloudwatch {
 
             let detailType = try container.decode(String.self, forKey: .detailType)
             guard detailType.lowercased() == Detail.name.lowercased() else {
-                throw PayloadTypeMismatch(name: detailType, type: Detail.self)
+                throw DetailTypeMismatch(name: detailType, type: Detail.self)
             }
 
             self.detail = try container.decode(Detail.self, forKey: .detail)
@@ -122,7 +122,7 @@ public enum Cloudwatch {
         }
     }
 
-    struct PayloadTypeMismatch: Error {
+    struct DetailTypeMismatch: Error {
         let name: String
         let type: Any
     }

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -18,7 +18,7 @@ import class Foundation.JSONEncoder
 import NIO
 import NIOFoundationCompat
 
-/// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `Codable` payloads.
+/// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `Codable` events.
 extension Lambda {
     /// An asynchronous Lambda Closure that takes a `In: Decodable` and returns a `Result<Out: Encodable, Error>` via a completion handler.
     public typealias CodableClosure<In: Decodable, Out: Encodable> = (Lambda.Context, In, @escaping (Result<Out, Error>) -> Void) -> Void
@@ -57,8 +57,8 @@ internal struct CodableClosureWrapper<In: Decodable, Out: Encodable>: LambdaHand
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, payload: In, callback: @escaping (Result<Out, Error>) -> Void) {
-        self.closure(context, payload, callback)
+    func handle(context: Lambda.Context, event: In, callback: @escaping (Result<Out, Error>) -> Void) {
+        self.closure(context, event, callback)
     }
 }
 
@@ -72,8 +72,8 @@ internal struct CodableVoidClosureWrapper<In: Decodable>: LambdaHandler {
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, payload: In, callback: @escaping (Result<Out, Error>) -> Void) {
-        self.closure(context, payload, callback)
+    func handle(context: Lambda.Context, event: In, callback: @escaping (Result<Out, Error>) -> Void) {
+        self.closure(context, event, callback)
     }
 }
 

Sources/AWSLambdaRuntimeCore/Lambda+LocalServer.swift

@@ -23,15 +23,15 @@ import NIOHTTP1
 // For example:
 //
 // try Lambda.withLocalServer {
-//     Lambda.run { (context: Lambda.Context, payload: String, callback: @escaping (Result<String, Error>) -> Void) in
-//         callback(.success("Hello, \(payload)!"))
+//     Lambda.run { (context: Lambda.Context, event: String, callback: @escaping (Result<String, Error>) -> Void) in
+//         callback(.success("Hello, \(event)!"))
 //     }
 // }
 extension Lambda {
     /// Execute code in the context of a mock Lambda server.
     ///
     /// - parameters:
-    ///     - invocationEndpoint: The endpoint  to post payloads to.
+    ///     - invocationEndpoint: The endpoint  to post events to.
     ///     - body: Code to run within the context of the mock server. Typically this would be a Lambda.run function call.
     ///
     /// - note: This API is designed stricly for local testing and is behind a DEBUG flag
@@ -77,7 +77,7 @@ private enum LocalLambda {
                 guard channel.localAddress != nil else {
                     return channel.eventLoop.makeFailedFuture(ServerError.cantBind)
                 }
-                self.logger.info("LocalLambdaServer started and listening on \(self.host):\(self.port), receiving payloads on \(self.invocationEndpoint)")
+                self.logger.info("LocalLambdaServer started and listening on \(self.host):\(self.port), receiving events on \(self.invocationEndpoint)")
                 return channel.eventLoop.makeSucceededFuture(())
             }
         }

Sources/AWSLambdaRuntimeCore/Lambda+String.swift

@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 import NIO
 
-/// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `String` payloads.
+/// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `String` events.
 extension Lambda {
     /// An asynchronous Lambda Closure that takes a `String` and returns a `Result<String, Error>` via a completion handler.
     public typealias StringClosure = (Lambda.Context, String, @escaping (Result<String, Error>) -> Void) -> Void
@@ -64,8 +64,8 @@ internal struct StringClosureWrapper: LambdaHandler {
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, payload: In, callback: @escaping (Result<Out, Error>) -> Void) {
-        self.closure(context, payload, callback)
+    func handle(context: Lambda.Context, event: In, callback: @escaping (Result<Out, Error>) -> Void) {
+        self.closure(context, event, callback)
     }
 }
 
@@ -79,8 +79,8 @@ internal struct StringVoidClosureWrapper: LambdaHandler {
         self.closure = closure
     }
 
-    func handle(context: Lambda.Context, payload: In, callback: @escaping (Result<Out, Error>) -> Void) {
-        self.closure(context, payload, callback)
+    func handle(context: Lambda.Context, event: In, callback: @escaping (Result<Out, Error>) -> Void) {
+        self.closure(context, event, callback)
     }
 }
 

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -33,10 +33,10 @@ public protocol LambdaHandler: EventLoopLambdaHandler {
     ///
     /// - parameters:
     ///     - context: Runtime `Context`.
-    ///     - payload: Payload of type `In` representing the event or request.
+    ///     - event: Event of type `In` representing the event or request.
     ///     - callback: Completion handler to report the result of the Lambda back to the runtime engine.
     ///                 The completion handler expects a `Result` with either a response of type `Out` or an `Error`
-    func handle(context: Lambda.Context, payload: In, callback: @escaping (Result<Out, Error>) -> Void)
+    func handle(context: Lambda.Context, event: In, callback: @escaping (Result<Out, Error>) -> Void)
 }
 
 internal extension Lambda {
@@ -52,11 +52,11 @@ public extension LambdaHandler {
     /// `LambdaHandler` is offloading the processing to a `DispatchQueue`
     /// This is slower but safer, in case the implementation blocks the `EventLoop`
     /// Performance sensitive Lambdas should be based on `EventLoopLambdaHandler` which does not offload.
-    func handle(context: Lambda.Context, payload: In) -> EventLoopFuture<Out> {
+    func handle(context: Lambda.Context, event: In) -> EventLoopFuture<Out> {
         let promise = context.eventLoop.makePromise(of: Out.self)
         // FIXME: reusable DispatchQueue
         self.offloadQueue.async {
-            self.handle(context: context, payload: payload, callback: promise.completeWith)
+            self.handle(context: context, event: event, callback: promise.completeWith)
         }
         return promise.futureResult
     }
@@ -80,11 +80,11 @@ public protocol EventLoopLambdaHandler: ByteBufferLambdaHandler {
     ///
     /// - parameters:
     ///     - context: Runtime `Context`.
-    ///     - payload: Payload of type `In` representing the event or request.
+    ///     - event: Event of type `In` representing the event or request.
     ///
     /// - Returns: An `EventLoopFuture` to report the result of the Lambda back to the runtime engine.
     ///            The `EventLoopFuture` should be completed with either a response of type `Out` or an `Error`
-    func handle(context: Lambda.Context, payload: In) -> EventLoopFuture<Out>
+    func handle(context: Lambda.Context, event: In) -> EventLoopFuture<Out>
 
     /// Encode a response of type `Out` to `ByteBuffer`
     /// Concrete Lambda handlers implement this method to provide coding functionality.
@@ -107,12 +107,12 @@ public protocol EventLoopLambdaHandler: ByteBufferLambdaHandler {
 
 public extension EventLoopLambdaHandler {
     /// Driver for `ByteBuffer` -> `In` decoding and `Out` -> `ByteBuffer` encoding
-    func handle(context: Lambda.Context, payload: ByteBuffer) -> EventLoopFuture<ByteBuffer?> {
-        switch self.decodeIn(buffer: payload) {
+    func handle(context: Lambda.Context, event: ByteBuffer) -> EventLoopFuture<ByteBuffer?> {
+        switch self.decodeIn(buffer: event) {
         case .failure(let error):
             return context.eventLoop.makeFailedFuture(CodecError.requestDecoding(error))
         case .success(let `in`):
-            return self.handle(context: context, payload: `in`).flatMapThrowing { out in
+            return self.handle(context: context, event: `in`).flatMapThrowing { out in
                 switch self.encodeOut(allocator: context.allocator, value: out) {
                 case .failure(let error):
                     throw CodecError.responseEncoding(error)
@@ -159,11 +159,11 @@ public protocol ByteBufferLambdaHandler {
     ///
     /// - parameters:
     ///     - context: Runtime `Context`.
-    ///     - payload: The event or request payload encoded as `ByteBuffer`.
+    ///     - event: The event or input payload encoded as `ByteBuffer`.
     ///
     /// - Returns: An `EventLoopFuture` to report the result of the Lambda back to the runtime engine.
     ///            The `EventLoopFuture` should be completed with either a response encoded as `ByteBuffer` or an `Error`
-    func handle(context: Lambda.Context, payload: ByteBuffer) -> EventLoopFuture<ByteBuffer?>
+    func handle(context: Lambda.Context, event: ByteBuffer) -> EventLoopFuture<ByteBuffer?>
 }
 
 private enum CodecError: Error {

Sources/AWSLambdaRuntimeCore/LambdaRunner.swift

@@ -51,12 +51,12 @@ extension Lambda {
             self.isGettingNextInvocation = true
             return self.runtimeClient.getNextInvocation(logger: logger).peekError { error in
                 logger.error("could not fetch work from lambda runtime engine: \(error)")
-            }.flatMap { invocation, payload in
+            }.flatMap { invocation, event in
                 // 2. send invocation to handler
                 self.isGettingNextInvocation = false
                 let context = Context(logger: logger, eventLoop: self.eventLoop, invocation: invocation)
                 logger.debug("sending invocation to lambda handler \(handler)")
-                return handler.handle(context: context, payload: payload)
+                return handler.handle(context: context, event: event)
                     .mapResult { result in
                         if case .failure(let error) = result {
                             logger.warning("lambda handler returned an error: \(error)")

Sources/AWSLambdaRuntimeCore/LambdaRuntimeClient.swift

@@ -41,10 +41,10 @@ extension Lambda {
                     throw RuntimeError.badStatusCode(response.status)
                 }
                 let invocation = try Invocation(headers: response.headers)
-                guard let payload = response.body else {
+                guard let event = response.body else {
                     throw RuntimeError.noBody
                 }
-                return (invocation, payload)
+                return (invocation, event)
             }.flatMapErrorThrowing { error in
                 switch error {
                 case HTTPClient.Errors.timeout: