Add new LambdaRuntime

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -184,3 +184,117 @@ extension LambdaCodableAdapter {
         )
     }
 }
+
+extension NewLambdaRuntime {
+    /// Initialize an instance with a ``StreamingLambdaHandler`` in the form of a closure.
+    /// - Parameter body: The handler in the form of a closure.
+    package convenience init(
+        body: @Sendable @escaping (ByteBuffer, LambdaResponseStreamWriter, NewLambdaContext) async throws -> Void
+    ) where Handler == StreamingClosureHandler {
+        self.init(handler: StreamingClosureHandler(body: body))
+    }
+
+    /// Initialize an instance with a ``NewLambdaHandler`` defined in the form of a closure **with a non-`Void` return type**, an encoder, and a decoder.
+    /// - Parameter body: The handler in the form of a closure.
+    /// - Parameter encoder: The encoder object that will be used to encode the generic ``Output`` into a ``ByteBuffer``.
+    /// - Parameter decoder: The decoder object that will be used to decode the incoming ``ByteBuffer`` event into the generic ``Event`` type.
+    package convenience init<
+        Event: Decodable,
+        Output: Encodable,
+        Encoder: LambdaOutputEncoder,
+        Decoder: LambdaEventDecoder
+    >(
+        encoder: Encoder,
+        decoder: Decoder,
+        body: @escaping (Event, NewLambdaContext) async throws -> Output
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Output, ClosureHandler<Event, Output>>,
+            Event,
+            Output,
+            Decoder,
+            Encoder
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            encoder: encoder,
+            decoder: decoder,
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.init(handler: handler)
+    }
+
+    /// Initialize an instance with a ``NewLambdaHandler`` defined in the form of a closure **with a `Void` return type**, an encoder, and a decoder.
+    /// - Parameter body: The handler in the form of a closure.
+    /// - Parameter encoder: The encoder object that will be used to encode the generic ``Output`` into a ``ByteBuffer``.
+    /// - Parameter decoder: The decoder object that will be used to decode the incoming ``ByteBuffer`` event into the generic ``Event`` type.
+    package convenience init<Event: Decodable, Decoder: LambdaEventDecoder>(
+        decoder: Decoder,
+        body: @escaping (Event, NewLambdaContext) async throws -> Void
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Void, ClosureHandler<Event, Void>>,
+            Event,
+            Void,
+            Decoder,
+            VoidEncoder
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            decoder: decoder,
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.init(handler: handler)
+    }
+
+    /// Initialize an instance with a ``NewLambdaHandler`` defined in the form of a closure **with a non-`Void` return type**.
+    /// - note: ``JSONEncoder`` and ``JSONDecoder`` are used as the encoder and decoder objects. Use ``init(encoder:decoder:body:)`` to specify custom encoder and decoder objects.
+    /// - Parameter body: The handler in the form of a closure.
+    package convenience init<Event: Decodable, Output>(
+        body: @escaping (Event, NewLambdaContext) async throws -> Output
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Output, ClosureHandler<Event, Output>>,
+            Event,
+            Output,
+            JSONDecoder,
+            LambdaJSONOutputEncoder<Output>
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            encoder: JSONEncoder(),
+            decoder: JSONDecoder(),
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.init(handler: handler)
+    }
+
+    /// Initialize an instance with a ``NewLambdaHandler`` defined in the form of a closure **with a `Void` return type**.
+    /// - note: ``JSONDecoder`` is used as the decoder object. Use ``init(decoder:body:)`` to specify a custom decoder object.
+    /// - Parameter body: The handler in the form of a closure.
+    package convenience init<Event: Decodable>(
+        body: @escaping (Event, NewLambdaContext) async throws -> Void
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Void, ClosureHandler<Event, Void>>,
+            Event,
+            Void,
+            JSONDecoder,
+            VoidEncoder
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            decoder: JSONDecoder(),
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.init(handler: handler)
+    }
+}

Sources/AWSLambdaRuntimeCore/NewLambda.swift

@@ -14,6 +14,7 @@
 
 import Dispatch
 import Logging
+import NIOCore
 
 extension Lambda {
     package static func runLoop<RuntimeClient: LambdaRuntimeClientProtocol, Handler>(
@@ -44,4 +45,11 @@ extension Lambda {
             }
         }
     }
+
+    /// The default EventLoop the Lambda is scheduled on.
+    package static var defaultEventLoop: any EventLoop {
+        get {
+            NIOSingletons.posixEventLoopGroup.next()
+        }
+    }
 }

Sources/AWSLambdaRuntimeCore/NewLambdaRuntime.swift

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 Foundation
+//import ServiceLifecycle
+import Logging
+import NIOCore
+import Synchronization
+
+package final class NewLambdaRuntime<Handler>: Sendable where Handler: StreamingLambdaHandler {
+    let handlerMutex: Mutex<Handler>
+    let logger: Logger
+    let eventLoop: EventLoop
+
+    package init(
+        handler: sending Handler,
+        eventLoop: EventLoop = Lambda.defaultEventLoop,
+        logger: Logger = Logger(label: "LambdaRuntime")
+    ) {
+        self.handlerMutex = Mutex(handler)
+        self.eventLoop = eventLoop
+        self.logger = logger
+    }
+
+    package func run() async throws {
+    }
+}