suggestion

Author: tomerd

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -82,36 +82,51 @@ internal struct CodableVoidLambdaClosureWrapper<In: Decodable>: LambdaHandler {
     }
 }
 
-/// Implementation of  a`ByteBuffer` to `In` and `Out` to `ByteBuffer` codec
-/// Using Foundation's JSONEncoder and JSONDecoder
-/// Advanced users that want to inject their own codec can do it by overriding these functions.
-public extension EventLoopLambdaHandler where In: Decodable, Out: Encodable {
+/// Implementation of  a`ByteBuffer` to `In` decoding
+public extension EventLoopLambdaHandler where In: Decodable {
+    func decode(buffer: ByteBuffer) throws -> In {
+        try self.decoder.decode(In.self, from: buffer)
+    }
+}
+
+/// Implementation of  `Out` to `ByteBuffer` encoding
+public extension EventLoopLambdaHandler where Out: Encodable {
     func encode(allocator: ByteBufferAllocator, value: Out) throws -> ByteBuffer? {
         // nio will resize the buffer if necessary
         var buffer = allocator.buffer(capacity: 1024)
-        try Lambda.defaultJSONEncoder.encode(value, into: &buffer)
+        try self.encoder.encode(value, into: &buffer)
         return buffer
     }
+}
 
-    func decode(buffer: ByteBuffer) throws -> In {
-        try Lambda.defaultJSONDecoder.decode(In.self, from: buffer)
+/// Default `ByteBuffer` to `In` decoder using Foundation's JSONDecoder
+/// Advanced users that want to inject their own codec can do it by overriding these functions.
+public extension EventLoopLambdaHandler where In: Decodable {
+    var decoder: LambdaCodableDecoder {
+        Lambda.defaultJSONDecoder
     }
 }
 
-private extension Lambda {
-    /// the default json encoder used in `EventLoopLambdaHandler` if Out == Encodable
-    static let defaultJSONEncoder = JSONEncoder()
+/// Default `Out` to `ByteBuffer` encoder using Foundation's JSONEncoder
+/// Advanced users that want to inject their own codec can do it by overriding these functions.
+public extension EventLoopLambdaHandler where Out: Encodable {
+    var encoder: LambdaCodableEncoder {
+        Lambda.defaultJSONEncoder
+    }
+}
 
-    /// the default json decoder used in `EventLoopLambdaHandler` if In == Decodable
-    static let defaultJSONDecoder = JSONDecoder()
+public protocol LambdaCodableDecoder {
+    func decode<T: Decodable>(_ type: T.Type, from buffer: ByteBuffer) throws -> T
 }
 
-public extension EventLoopLambdaHandler where In: Decodable, Out == Void {
-    func encode(allocator: ByteBufferAllocator, value: Void) throws -> ByteBuffer? {
-        nil
-    }
+public protocol LambdaCodableEncoder {
+    func encode<T: Encodable>(_ value: T, into buffer: inout ByteBuffer) throws
+}
 
-    func decode(buffer: ByteBuffer) throws -> In {
-        try Lambda.defaultJSONDecoder.decode(In.self, from: buffer)
-    }
+private extension Lambda {
+    static let defaultJSONDecoder = JSONDecoder()
+    static let defaultJSONEncoder = JSONEncoder()
 }
+
+extension JSONDecoder: LambdaCodableDecoder {}
+extension JSONEncoder: LambdaCodableEncoder {}

Sources/AWSLambdaRuntime/Lambda+String.swift

@@ -78,15 +78,8 @@ internal struct StringVoidLambdaClosureWrapper: LambdaHandler {
     }
 }
 
-/// Implementation of  a`ByteBuffer` to `String` and `String` to `ByteBuffer` codec
-public extension EventLoopLambdaHandler where In == String, Out == String {
-    func encode(allocator: ByteBufferAllocator, value: String) throws -> ByteBuffer? {
-        // FIXME: reusable buffer
-        var buffer = allocator.buffer(capacity: value.utf8.count)
-        buffer.writeString(value)
-        return buffer
-    }
-
+/// Implementation of  a`ByteBuffer` to `String` encoding
+public extension EventLoopLambdaHandler where In == String {
     func decode(buffer: ByteBuffer) throws -> String {
         var buffer = buffer
         guard let string = buffer.readString(length: buffer.readableBytes) else {
@@ -96,16 +89,12 @@ public extension EventLoopLambdaHandler where In == String, Out == String {
     }
 }
 
-public extension EventLoopLambdaHandler where In == String, Out == Void {
-    func encode(allocator: ByteBufferAllocator, value: Void) throws -> ByteBuffer? {
-        nil
-    }
-
-    func decode(buffer: ByteBuffer) throws -> String {
-        var buffer = buffer
-        guard let string = buffer.readString(length: buffer.readableBytes) else {
-            fatalError("buffer.readString(length: buffer.readableBytes) failed")
-        }
-        return string
+/// Implementation of  `String` to `ByteBuffer` decoding
+public extension EventLoopLambdaHandler where Out == String {
+    func encode(allocator: ByteBufferAllocator, value: String) throws -> ByteBuffer? {
+        // FIXME: reusable buffer
+        var buffer = allocator.buffer(capacity: value.utf8.count)
+        buffer.writeString(value)
+        return buffer
     }
 }

Sources/AWSLambdaRuntime/LambdaHandler.swift

@@ -107,6 +107,13 @@ public extension EventLoopLambdaHandler {
     }
 }
 
+/// Implementation of  `ByteBuffer` to `Void` decoding
+public extension EventLoopLambdaHandler where Out == Void {
+    func encode(allocator: ByteBufferAllocator, value: Void) throws -> ByteBuffer? {
+        nil
+    }
+}
+
 // MARK: - ByteBufferLambdaHandler
 
 /// An `EventLoopFuture` based processing protocol for a Lambda that takes a `ByteBuffer` and returns a `ByteBuffer?` asynchronously.