more api thgouhts

Author: tomerd

Sources/SwiftAwsLambda/Lambda+Codable.swift

@@ -19,88 +19,145 @@ import NIOFoundationCompat
 /// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `Codable` payloads.
 /// This is the most common way to use this library in AWS Lambda, since its JSON based.
 extension Lambda {
-    /// Run a Lambda defined by implementing the `LambdaCodableClosure` closure, having `In` and `Out` extending `Decodable` and `Encodable` respectively.
+    /// Run a Lambda defined by implementing the `CodableLambda.Closure` closure, having `In` and `Out` extending `Decodable` and `Encodable` respectively.
     ///
     /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run<In: Decodable, Out: Encodable>(_ closure: @escaping LambdaCodableClosure<In, Out>) {
-        self.run(LambdaClosureWrapper(closure))
+    public static func run<In: Decodable, Out: Encodable>(_ closure: @escaping CodableLambda.Closure<In, Out>) {
+        self.run(ClosureWrapper(closure))
     }
 
-    /// Run a Lambda defined by implementing the `LambdaCodableHandler` protocol, having `In` and `Out` are `Decodable` and `Encodable` respectively.
+    /// Run a Lambda defined by implementing the `CodableLambdaHandler` protocol, having `In` and `Out` are `Decodable` and `Encodable` respectively.
     ///
     /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run<Handler>(_ handler: Handler) where Handler: LambdaCodableHandler {
-        self.run(handler as LambdaHandler)
+    public static func run<Handler>(_ handler: Handler) where Handler: CodableLambdaHandler {
+        self.run { _ in handler }
+    }
+
+    /// Run a Lambda defined by implementing the `CodableLambdaHandler` protocol, having `In` and `Out` are `Decodable` and `Encodable` respectively.
+    ///
+    /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
+    public static func run<Handler>(_ provider: @escaping (EventLoop) throws -> Handler) where Handler: CodableLambdaHandler {
+        self.run { try provider($0) as LambdaHandler }
     }
 
     // for testing
-    internal static func run<In: Decodable, Out: Encodable>(configuration: Configuration = .init(), closure: @escaping LambdaCodableClosure<In, Out>) -> Result<Int, Error> {
-        return self.run(handler: LambdaClosureWrapper(closure), configuration: configuration)
+    internal static func run<In: Decodable, Out: Encodable>(configuration: Configuration = .init(), closure: @escaping CodableLambda.Closure<In, Out>) -> Result<Int, Error> {
+        return self.run(provider: { _ in ClosureWrapper(closure) }, configuration: configuration)
     }
 
     // for testing
-    internal static func run<Handler>(handler: Handler, configuration: Configuration = .init()) -> Result<Int, Error> where Handler: LambdaCodableHandler {
+    internal static func run<Handler>(handler: Handler, configuration: Configuration = .init()) -> Result<Int, Error> where Handler: CodableLambdaHandler {
         return self.run(handler: handler as LambdaHandler, configuration: configuration)
     }
+
+    // for testing
+    internal static func run<Handler>(provider: @escaping (EventLoop) throws -> Handler, configuration: Configuration = .init()) -> Result<Int, Error> where Handler: CodableLambdaHandler {
+        return self.run(provider: { try provider($0) as LambdaHandler }, configuration: configuration)
+    }
 }
 
-/// A callback for a Lambda that returns a `Result<Out, Error>` result type, having `Out` extend `Encodable`.
-public typealias LambdaCodableCallback<Out> = (Result<Out, Error>) -> Void
+public enum CodableLambda {
+    /// A completion handler for a Lambda that returns a `Result<Out, Error>` result type.
+    public typealias CompletionHandler<Out> = (Result<Out, Error>?) -> Void
 
-/// A processing closure for a Lambda that takes an `In` and returns an `Out` via `LambdaCodableCallback<Out>` asynchronously,
-/// having `In` and `Out` extending `Decodable` and `Encodable` respectively.
-public typealias LambdaCodableClosure<In, Out> = (LambdaContext, In, LambdaCodableCallback<Out>) -> Void
+    /// A processing closure for a Lambda that takes a `String` and returns a `Result<Out, Error>` via `CompletionHandler` asynchronously.
+    public typealias Closure<In, Out> = (Lambda.Context, In, CompletionHandler<Out>) -> Void
+}
 
-/// A processing protocol for a Lambda that takes an `In` and returns an `Out` via `LambdaCodableCallback<Out>` asynchronously,
+/// A processing protocol for a Lambda that takes an `In` and returns an optional `Out`asynchronously via a `CompletionHandler<Out>` ,
 /// having `In` and `Out` extending `Decodable` and `Encodable` respectively.
-public protocol LambdaCodableHandler: LambdaHandler {
+public protocol CodableLambdaHandler: LambdaHandler {
     associatedtype In: Decodable
     associatedtype Out: Encodable
 
-    func handle(context: LambdaContext, payload: In, callback: @escaping LambdaCodableCallback<Out>)
     var codec: LambdaCodableCodec<In, Out> { get }
+
+    func handle(context: Lambda.Context, payload: In, callback: @escaping CodableLambda.CompletionHandler<Out>)
 }
 
-/// Default implementation for `LambdaCodableHandler` codec which uses JSON via `LambdaCodableJsonCodec`.
+/// A processing protocol for a Lambda that takes a `In` and returns an optional `Out`  asynchronously via an `EventLoopPromise`.
+public protocol CodablePromiseLambdaHandler: LambdaHandler {
+    associatedtype In: Decodable
+    associatedtype Out: Encodable
+
+    var codec: LambdaCodableCodec<In, Out> { get }
+
+    func handle(context: Lambda.Context, payload: In, promise: EventLoopPromise<Out?>)
+}
+
+/// Default implementation for `CodableLambdaHandler` codec which uses JSON via `LambdaCodableJsonCodec`.
 /// Advanced users that want to inject their own codec can do it by overriding this.
-public extension LambdaCodableHandler {
+public extension CodableLambdaHandler {
     var codec: LambdaCodableCodec<In, Out> {
-        return LambdaCodableJsonCodec<In, Out>()
+        LambdaCodableJsonCodec<In, Out>()
     }
 }
 
-/// LambdaCodableCodec is an abstract/empty implementation for codec which does `Encodable` -> `[UInt8]` encoding and `[UInt8]` -> `Decodable' decoding.
+/// Default implementation for `CodableLambdaHandler` codec which uses JSON via `LambdaCodableJsonCodec`.
+/// Advanced users that want to inject their own codec can do it by overriding this.
+public extension CodablePromiseLambdaHandler {
+    var codec: LambdaCodableCodec<In, Out> {
+        LambdaCodableJsonCodec<In, Out>()
+    }
+}
+
+/// LambdaCodableCodec is an abstract/empty implementation for codec which does `Encodable` -> `ByteBuffer` encoding and `ByteBuffer` -> `Decodable` decoding.
 // TODO: would be nicer to use a protocol instead of this "abstract class", but generics get in the way
 public class LambdaCodableCodec<In: Decodable, Out: Encodable> {
     func encode(_: Out) -> Result<ByteBuffer, Error> { fatalError("not implmented") }
     func decode(_: ByteBuffer) -> Result<In, Error> { fatalError("not implmented") }
 }
 
-/// Default implementation of `Encodable` -> `[UInt8]` encoding and `[UInt8]` -> `Decodable' decoding
-public extension LambdaCodableHandler {
-    func handle(context: LambdaContext, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer>) {
+/// Default implementation of `Encodable` -> `ByteBuffer` encoding and `ByteBuffer` -> `Decodable` decoding
+public extension CodableLambdaHandler {
+    func handle(context: Lambda.Context, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer?>) {
         switch self.codec.decode(payload) {
         case .failure(let error):
             return promise.fail(Errors.requestDecoding(error))
         case .success(let payloadAsCodable):
             self.handle(context: context, payload: payloadAsCodable) { result in
                 switch result {
+                case .none:
+                    promise.succeed(nil)
                 case .failure(let error):
-                    return promise.fail(error)
+                    promise.fail(error)
                 case .success(let encodable):
                     switch self.codec.encode(encodable) {
                     case .failure(let error):
-                        return promise.fail(Errors.responseEncoding(error))
+                        promise.fail(Errors.responseEncoding(error))
                     case .success(let buffer):
-                        return promise.succeed(buffer)
+                        promise.succeed(buffer)
                     }
                 }
             }
         }
     }
 }
 
-/// LambdaCodableJsonCodec is an implementation of `LambdaCodableCodec` which does `Encodable` -> `[UInt8]` encoding and `[UInt8]` -> `Decodable' decoding
+/// Default implementation of `Encodable` -> `ByteBuffer` encoding and `ByteBuffer` -> `Decodable'`decoding
+public extension CodablePromiseLambdaHandler {
+    func handle(context: Lambda.Context, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer?>) {
+        switch self.codec.decode(payload) {
+        case .failure(let error):
+            return promise.fail(Errors.requestDecoding(error))
+        case .success(let decodable):
+            let encodablePromise = context.eventLoop.makePromise(of: Out?.self)
+            encodablePromise.futureResult.flatMapThrowing { encodable in
+                try encodable.flatMap { encodable in
+                    switch self.codec.encode(encodable) {
+                    case .failure(let error):
+                        throw Errors.responseEncoding(error)
+                    case .success(let buffer):
+                        return buffer
+                    }
+                }
+            }.cascade(to: promise)
+            self.handle(context: context, payload: decodable, promise: encodablePromise)
+        }
+    }
+}
+
+/// LambdaCodableJsonCodec is an implementation of `LambdaCodableCodec` which does `Encodable` -> `ByteBuffer` encoding and `ByteBuffer` -> `Decodable' decoding
 /// using JSONEncoder and JSONDecoder respectively.
 // This is a class as encoder amd decoder are a class, which means its cheaper to hold a reference to both in a class then a struct.
 private final class LambdaCodableJsonCodec<In: Decodable, Out: Encodable>: LambdaCodableCodec<In, Out> {
@@ -131,15 +188,16 @@ private final class LambdaCodableJsonCodec<In: Decodable, Out: Encodable>: Lambd
     }
 }
 
-private struct LambdaClosureWrapper<In: Decodable, Out: Encodable>: LambdaCodableHandler {
+private struct ClosureWrapper<In: Decodable, Out: Encodable>: CodableLambdaHandler {
     typealias Codec = LambdaCodableJsonCodec<In, Out>
 
-    private let closure: LambdaCodableClosure<In, Out>
-    init(_ closure: @escaping LambdaCodableClosure<In, Out>) {
+    private let closure: CodableLambda.Closure<In, Out>
+
+    init(_ closure: @escaping CodableLambda.Closure<In, Out>) {
         self.closure = closure
     }
 
-    public func handle(context: LambdaContext, payload: In, callback: @escaping LambdaCodableCallback<Out>) {
+    public func handle(context: Lambda.Context, payload: In, callback: @escaping CodableLambda.CompletionHandler<Out>) {
         self.closure(context, payload, callback)
     }
 }

Sources/SwiftAwsLambda/Lambda+String.swift

@@ -16,68 +16,108 @@ import NIO
 
 /// Extension to the `Lambda` companion to enable execution of Lambdas that take and return `String` payloads.
 extension Lambda {
-    /// Run a Lambda defined by implementing the `LambdaStringClosure` protocol.
+    /// Run a Lambda defined by implementing the `StringLambda.Closure` protocol.
     ///
     /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run(_ closure: @escaping LambdaStringClosure) {
-        self.run(LambdaClosureWrapper(closure))
+    public static func run(_ closure: @escaping StringLambda.Closure) {
+        self.run(ClosureWrapper(closure))
     }
 
-    /// Run a Lambda defined by implementing the `LambdaStringHandler` protocol.
+    /// Run a Lambda defined by implementing the `StringLambdaHandler` protocol.
     ///
     /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
-    public static func run(_ handler: LambdaStringHandler) {
-        self.run(handler as LambdaHandler)
+    public static func run(_ handler: StringLambdaHandler) {
+        self.run { _ in handler }
+    }
+
+    /// Run a Lambda defined by implementing the `StringLambdaHandler` protocol.
+    ///
+    /// - note: This is a blocking operation that will run forever, as it's lifecycle is managed by the AWS Lambda Runtime Engine.
+    public static func run(_ provider: @escaping (EventLoop) throws -> StringLambdaHandler) {
+        self.run(provider: { try provider($0) as LambdaHandler })
     }
 
     // for testing
-    internal static func run(configuration: Configuration = .init(), _ closure: @escaping LambdaStringClosure) -> Result<Int, Error> {
-        return self.run(handler: LambdaClosureWrapper(closure), configuration: configuration)
+    internal static func run(configuration: Configuration = .init(), closure: @escaping StringLambda.Closure) -> Result<Int, Error> {
+        return self.run(handler: ClosureWrapper(closure), configuration: configuration)
     }
 
     // for testing
-    internal static func run(handler: LambdaStringHandler, configuration: Configuration = .init()) -> Result<Int, Error> {
+    internal static func run(handler: StringLambdaHandler, configuration: Configuration = .init()) -> Result<Int, Error> {
         return self.run(handler: handler as LambdaHandler, configuration: configuration)
     }
+
+    // for testing
+    internal static func run(provider: @escaping (EventLoop) throws -> StringLambdaHandler, configuration: Configuration = .init()) -> Result<Int, Error> {
+        return self.run(provider: { try provider($0) as LambdaHandler }, configuration: configuration)
+    }
 }
 
-/// A callback for a Lambda that returns a `Result<String, Error>` result type.
-public typealias LambdaStringCallback = (Result<String, Error>) -> Void
+public enum StringLambda {
+    /// A completion handler for a Lambda that returns a `Result<String, Error>` result type.
+    public typealias CompletionHandler = (Result<String, Error>?) -> Void
 
-/// A processing closure for a Lambda that takes a `String` and returns a `LambdaStringResult` via `LambdaStringCallback` asynchronously.
-public typealias LambdaStringClosure = (LambdaContext, String, LambdaStringCallback) -> Void
+    /// A processing closure for a Lambda that takes a `String` and returns a `Result<String, Error>` via `CompletionHandler` asynchronously.
+    public typealias Closure = (Lambda.Context, String, CompletionHandler) -> Void
+}
 
-/// A processing protocol for a Lambda that takes a `String` and returns a `LambdaStringResult` via `LambdaStringCallback` asynchronously.
-public protocol LambdaStringHandler: LambdaHandler {
-    func handle(context: LambdaContext, payload: String, callback: @escaping LambdaStringCallback)
+/// A processing protocol for a Lambda that takes a `String` and returns an optional `String`  asynchronously via an `CompletionHandler`.
+public protocol StringLambdaHandler: LambdaHandler {
+    func handle(context: Lambda.Context, payload: String, callback: @escaping StringLambda.CompletionHandler)
 }
 
-/// Default implementation of `String` -> `[UInt8]` encoding and `[UInt8]` -> `String' decoding
-public extension LambdaStringHandler {
-    func handle(context: LambdaContext, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer>) {
+/// A processing protocol for a Lambda that takes a `String` and returns an optional `String`  asynchronously via an `EventLoopPromise`.
+public protocol StringPromiseLambdaHandler: LambdaHandler {
+    func handle(context: Lambda.Context, payload: String, promise: EventLoopPromise<String?>)
+}
+
+/// Default implementation of `String` -> `ByteBuffer` encoding and `ByteBuffer` -> `String` decoding
+public extension StringLambdaHandler {
+    func handle(context: Lambda.Context, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer?>) {
         guard let payload = payload.getString(at: payload.readerIndex, length: payload.readableBytes) else {
             return promise.fail(Errors.invalidBuffer)
         }
         self.handle(context: context, payload: payload) { result in
             switch result {
+            case .none:
+                promise.succeed(nil)
+            case .failure(let error):
+                promise.fail(error)
             case .success(let string):
                 var buffer = context.allocator.buffer(capacity: string.utf8.count)
                 buffer.writeString(string)
-                return promise.succeed(buffer)
-            case .failure(let error):
-                return promise.fail(error)
+                promise.succeed(buffer)
             }
         }
     }
 }
 
-private struct LambdaClosureWrapper: LambdaStringHandler {
-    private let closure: LambdaStringClosure
-    init(_ closure: @escaping LambdaStringClosure) {
+/// Default implementation of `String` -> `ByteBuffer` encoding and `ByteBuffer` -> `String` decoding
+public extension StringPromiseLambdaHandler {
+    func handle(context: Lambda.Context, payload: ByteBuffer, promise: EventLoopPromise<ByteBuffer?>) {
+        guard let payload = payload.getString(at: payload.readerIndex, length: payload.readableBytes) else {
+            return promise.fail(Errors.invalidBuffer)
+        }
+        let stringPromise = context.eventLoop.makePromise(of: String?.self)
+        stringPromise.futureResult.map { string in
+            string.flatMap { string in
+                var buffer = context.allocator.buffer(capacity: string.utf8.count)
+                buffer.writeString(string)
+                return buffer
+            }
+        }.cascade(to: promise)
+        self.handle(context: context, payload: payload, promise: stringPromise)
+    }
+}
+
+private struct ClosureWrapper: StringLambdaHandler {
+    private let closure: StringLambda.Closure
+
+    init(_ closure: @escaping StringLambda.Closure) {
         self.closure = closure
     }
 
-    func handle(context: LambdaContext, payload: String, callback: @escaping LambdaStringCallback) {
+    func handle(context: Lambda.Context, payload: String, callback: @escaping StringLambda.CompletionHandler) {
         self.closure(context, payload, callback)
     }
 }