Add LambdaJSONOutputEncoder

Author: aryan-25

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -144,4 +144,37 @@ extension JSONDecoder: LambdaCodableDecoder {}
 extension JSONEncoder: LambdaCodableEncoder {}
 
 extension JSONDecoder: AWSLambdaRuntimeCore.LambdaEventDecoder {}
-extension JSONEncoder: AWSLambdaRuntimeCore.LambdaOutputEncoder {}
+
+@usableFromInline
+package struct LambdaJSONOutputEncoder<Output: Encodable>: LambdaOutputEncoder {
+    @usableFromInline let jsonEncoder: JSONEncoder
+
+    @inlinable
+    package init(_ jsonEncoder: JSONEncoder) {
+        self.jsonEncoder = jsonEncoder
+    }
+
+    @inlinable
+    package func encode(_ value: Output, into buffer: inout ByteBuffer) throws {
+        try self.jsonEncoder.encode(value, into: &buffer)
+    }
+}
+
+extension LambdaCodableAdapter {
+    /// Initializes an instance given an encoder, decoder, and a handler with a non-`Void` output.
+    ///   - Parameters:
+    ///   - encoder: The encoder object that will be used to encode the generic ``Output`` obtained from the `handler`'s `outputWriter` into a ``ByteBuffer``.
+    ///   - decoder: The decoder object that will be used to decode the received ``ByteBuffer`` event into the generic ``Event`` type served to the `handler`.
+    ///   - handler: The handler object.
+    package init(
+        encoder: JSONEncoder,
+        decoder: JSONDecoder,
+        handler: Handler
+    ) where Output: Encodable, Output == Handler.Output, Encoder == LambdaJSONOutputEncoder<Output>, Decoder == JSONDecoder {
+        self.init(
+            encoder: LambdaJSONOutputEncoder(encoder),
+            decoder: decoder,
+            handler: handler
+        )
+    }
+}

Sources/AWSLambdaRuntimeCore/NewLambdaContext.swift

@@ -126,8 +126,7 @@ package struct NewLambdaContext: CustomDebugStringConvertible, Sendable {
         traceID: String,
         invokedFunctionARN: String,
         timeout: DispatchTimeInterval,
-        logger: Logger,
-        eventLoop: EventLoop
+        logger: Logger
     ) -> NewLambdaContext {
         NewLambdaContext(
             requestID: requestID,

Tests/AWSLambdaRuntimeTests/NewLambda+CodableTests.swift

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2024 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Testing
+import AWSLambdaRuntime
+import NIOCore
+import Logging
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+@Suite
+struct JSONTests {
+
+    let logger = Logger(label: "JSONTests")
+
+    struct Foo: Codable {
+        var bar: String
+    }
+
+    @Test
+    func testEncodingConformance() {
+        let encoder = LambdaJSONOutputEncoder<Foo>(JSONEncoder())
+        let foo = Foo(bar: "baz")
+        var byteBuffer = ByteBuffer()
+
+        #expect(throws: Never.self) {
+            try encoder.encode(foo, into: &byteBuffer)
+        }
+
+        #expect(byteBuffer == ByteBuffer(string: #"{"bar":"baz"}"#))
+    }
+
+    @Test
+    func testJSONHandlerWithOutput() async {
+        let jsonEncoder = JSONEncoder()
+        let jsonDecoder = JSONDecoder()
+
+        let closureHandler = ClosureHandler { (foo: Foo, context) in
+            foo
+        }
+
+        var handler = LambdaCodableAdapter(encoder: jsonEncoder, decoder: jsonDecoder, handler: LambdaHandlerAdapter(handler: closureHandler))
+
+        let event = ByteBuffer(string: #"{"bar":"baz"}"#)
+        let writer = MockLambdaWriter()
+        let context = NewLambdaContext.__forTestsOnly(
+            requestID: UUID().uuidString,
+            traceID: UUID().uuidString,
+            invokedFunctionARN: "arn:",
+            timeout: .milliseconds(6000),
+            logger: self.logger
+        )
+
+        await #expect(throws: Never.self) {
+            try await handler.handle(event, responseWriter: writer, context: context)
+        }
+
+        let result = await writer.output
+        #expect(result == ByteBuffer(string: #"{"bar":"baz"}"#))
+    }
+}
+
+final actor MockLambdaWriter: LambdaResponseStreamWriter {
+    private var _buffer: ByteBuffer?
+
+    var output: ByteBuffer? {
+        self._buffer
+    }
+
+    func writeAndFinish(_ buffer: ByteBuffer) async throws {
+        self._buffer = buffer
+    }
+
+    func write(_ buffer: ByteBuffer) async throws {
+        fatalError("Unexpected call")
+    }
+
+    func finish() async throws {
+        fatalError("Unexpected call")
+    }
+}