move service conformance to a separate class

Author: sebsto

Package.swift

@@ -27,6 +27,7 @@ let package = Package(
             dependencies: [
                 .byName(name: "AWSLambdaRuntimeCore"),
                 .product(name: "NIOCore", package: "swift-nio"),
+                .product(name: "ServiceLifecycle", package: "swift-service-lifecycle"),
             ]
         ),
         .target(
@@ -37,7 +38,6 @@ let package = Package(
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "NIOConcurrencyHelpers", package: "swift-nio"),
                 .product(name: "NIOPosix", package: "swift-nio"),
-                .product(name: "ServiceLifecycle", package: "swift-service-lifecycle"),
             ],
             swiftSettings: [.swiftLanguageMode(.v5)]
         ),

Sources/AWSLambdaRuntime/LambdaRuntime+ServiceLifeCycle.swift

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2025 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
+//
+//===----------------------------------------------------------------------===//
+
+@_exported import AWSLambdaRuntimeCore
+import NIOCore
+
+import ServiceLifecycle
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import struct Foundation.Data
+import class Foundation.JSONDecoder
+import class Foundation.JSONEncoder
+#endif
+
+///
+/// Encapsulate a LambdaRuntime+Codable to offer the same API but this time exposed as a Swift Service
+/// This allows to continue to avoid the Service payload for Lambda functions that doesn't need it
+///
+public class LambdaRuntimeService<Handler>: Service, @unchecked Sendable where Handler: StreamingLambdaHandler  {
+
+    private let runtime: LambdaRuntime<Handler>
+
+    /// Initialize an instance with a `LambdaHandler` defined in the form of a closure **with a non-`Void` return type**.
+    /// - Parameters:
+    ///   - decoder: The decoder object that will be used to decode the incoming `ByteBuffer` event into the generic `Event` type. `JSONDecoder()` used as default.
+    ///   - encoder: The encoder object that will be used to encode the generic `Output` into a `ByteBuffer`. `JSONEncoder()` used as default.
+    ///   - body: The handler in the form of a closure.
+    public init<Event: Decodable, Output>(
+        decoder: JSONDecoder = JSONDecoder(),
+        encoder: JSONEncoder = JSONEncoder(),
+        body: sending @escaping (Event, LambdaContext) async throws -> Output
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Output, ClosureHandler<Event, Output>>,
+            Event,
+            Output,
+            LambdaJSONEventDecoder,
+            LambdaJSONOutputEncoder<Output>
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            encoder: encoder,
+            decoder: decoder,
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.runtime = LambdaRuntime(handler: handler)
+    }
+
+    /// Initialize an instance with a `LambdaHandler` defined in the form of a closure **with a `Void` return type**.
+    /// - Parameter body: The handler in the form of a closure.
+    /// - Parameter decoder: The decoder object that will be used to decode the incoming `ByteBuffer` event into the generic `Event` type. `JSONDecoder()` used as default.
+    public init<Event: Decodable>(
+        decoder: JSONDecoder = JSONDecoder(),
+        body: sending @escaping (Event, LambdaContext) async throws -> Void
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Void, ClosureHandler<Event, Void>>,
+            Event,
+            Void,
+            LambdaJSONEventDecoder,
+            VoidEncoder
+        >
+    {
+        let handler = LambdaCodableAdapter(
+            decoder: LambdaJSONEventDecoder(decoder),
+            handler: LambdaHandlerAdapter(handler: ClosureHandler(body: body))
+        )
+
+        self.runtime = LambdaRuntime(handler: handler)
+    }
+
+    public func run() async throws {
+        try await self.runtime.run()
+    }
+}

Sources/AWSLambdaRuntimeCore/LambdaRuntime.swift

@@ -15,7 +15,6 @@
 import Logging
 import NIOConcurrencyHelpers
 import NIOCore
-import ServiceLifecycle
 
 #if canImport(FoundationEssentials)
 import FoundationEssentials
@@ -26,12 +25,11 @@ import Foundation
 // We need `@unchecked` Sendable here, as `NIOLockedValueBox` does not understand `sending` today.
 // We don't want to use `NIOLockedValueBox` here anyway. We would love to use Mutex here, but this
 // sadly crashes the compiler today.
-public final class LambdaRuntime<Handler>: Service, @unchecked Sendable where Handler: StreamingLambdaHandler {
+public final class LambdaRuntime<Handler>: @unchecked Sendable where Handler: StreamingLambdaHandler {
     // TODO: We want to change this to Mutex as soon as this doesn't crash the Swift compiler on Linux anymore
     let handlerMutex: NIOLockedValueBox<Handler?>
 
-    // logger is accessible from the outside, but only mutable from the inside
-    public private(set) var logger: Logger
+    let logger: Logger
     let eventLoop: EventLoop
 
     public init(