Fix WebHook with Swift6

Author: Andrea Scuderi

Package.swift

@@ -1,39 +1,65 @@
-// swift-tools-version: 5.7
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
 
+#if os(macOS)
+let platforms: [PackageDescription.SupportedPlatform]? = [.macOS(.v15), .iOS(.v13)]
+#else
+let platforms: [PackageDescription.SupportedPlatform]? = nil
+#endif
+
 let package = Package(
     name: "BreezeLambdaWebHook",
-    platforms: [
-        .macOS(.v13),
-        .iOS(.v15)
-    ],
+    platforms: platforms,
     products: [
         .library(
-            name: "BreezeLambdaWebHook",
-            targets: ["BreezeLambdaWebHook"]
+            name: "BreezeLambdaWebHookService",
+            targets: ["BreezeLambdaWebHookService"]
+        ),
+        .library(
+            name: "BreezeHTTPClientService",
+            targets: ["BreezeHTTPClientService"]
+        ),
+        .executable(
+            name: "BreezeDemoHTTPApplication",
+            targets: ["BreezeDemoHTTPApplication"]
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.2"),
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.1.0"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", branch: "main"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.5.0"),
         .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.11.2"),
+        .package(url: "https://github.com/apple/swift-log.git", from: "1.6.2"),
     ],
     targets: [
         .target(
-            name: "BreezeLambdaWebHook",
+            name: "BreezeLambdaWebHookService",
             dependencies: [
+                "BreezeHTTPClientService",
                 .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
                 .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
                 .product(name: "AsyncHTTPClient", package: "async-http-client"),
             ]
         ),
+        .target(
+            name: "BreezeHTTPClientService",
+            dependencies: [
+                .product(name: "AsyncHTTPClient", package: "async-http-client"),
+                .product(name: "Logging", package: "swift-log")
+            ]
+        ),
+        .executableTarget(
+            name: "BreezeDemoHTTPApplication",
+            dependencies: [
+                "BreezeLambdaWebHookService"
+            ]
+        ),
         .testTarget(
             name: "BreezeLambdaWebHookTests",
             dependencies: [
-                .product(name: "AWSLambdaTesting", package: "swift-aws-lambda-runtime"),
-                "BreezeLambdaWebHook"
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+                "BreezeLambdaWebHookService"
             ],
             resources: [.copy("Fixtures")]
         ),

Sources/BreezeDemoHTTPApplication/BreezeDemoHTTPApplication.swift

@@ -0,0 +1,54 @@
+//    Copyright 2024 (c) Andrea Scuderi - https://github.com/swift-serverless
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+import BreezeLambdaWebHookService
+import BreezeHTTPClientService
+import AWSLambdaEvents
+import AWSLambdaRuntime
+import Logging
+
+struct DemoLambdaHandler: BreezeLambdaWebHookHandler, Sendable {
+    var handlerContext: HandlerContext
+    
+    init(handlerContext: HandlerContext) {
+        self.handlerContext = handlerContext
+    }
+    
+    func handle(_ event: APIGatewayV2Request, context: LambdaContext) async throws -> APIGatewayV2Response {
+        context.logger.info("Received event: \(event)")
+        return APIGatewayV2Response(with: "Hello World", statusCode: .ok)
+    }
+}
+
+@main
+struct BreezeDemoApplication {
+    static func main() async throws {
+        do {
+            let logger = Logger(label: "BreezeDemoApplication")
+            let httpClientService = BreezeHTTPClientService(
+                timeout: .seconds(60),
+                logger: logger
+            )
+            let lambdaService = BreezeLambdaWebHookService<DemoLambdaHandler>.init(
+                serviceConfig: BreezeClientServiceConfig(
+                    httpClientService: httpClientService,
+                    logger: logger
+                )
+            )
+            try await lambdaService.run()
+        } catch {
+            print(error.localizedDescription)
+        }
+    }
+}

Sources/BreezeHTTPClientService/BreezeClientServiceConfig.swift

@@ -0,0 +1,33 @@
+//    Copyright 2024 (c) Andrea Scuderi - https://github.com/swift-serverless
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+import Logging
+
+public enum BreezeClientServiceError: Error {
+    case invalidHttpClient
+}
+
+public struct BreezeClientServiceConfig: Sendable {
+    
+    public let httpClientService: BreezeHTTPClientServing
+    public let logger: Logger
+    
+    public init(
+        httpClientService: BreezeHTTPClientServing,
+        logger: Logger
+    ) {
+        self.httpClientService = httpClientService
+        self.logger = logger
+    }
+}

Sources/BreezeHTTPClientService/BreezeHTTPClientService.swift

@@ -0,0 +1,56 @@
+//    Copyright 2024 (c) Andrea Scuderi - https://github.com/swift-serverless
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+import ServiceLifecycle
+import AsyncHTTPClient
+import NIOCore
+import Logging
+
+public protocol BreezeHTTPClientServing: Actor, Service {
+    var httpClient: HTTPClient { get }
+}
+
+public actor BreezeHTTPClientService: BreezeHTTPClientServing {
+    
+    public let httpClient: HTTPClient
+    let logger: Logger
+    
+    public init(timeout: TimeAmount, logger: Logger) {
+        self.logger = logger
+        let timeout = HTTPClient.Configuration.Timeout(
+            connect: timeout,
+            read: timeout
+        )
+        let configuration = HTTPClient.Configuration(timeout: timeout)
+        self.httpClient = HTTPClient(
+            eventLoopGroupProvider: .singleton,
+            configuration: configuration
+        )
+        logger.info("HTTPClientService config:")
+        logger.info("timeout \(timeout)")
+    }
+
+    public func run() async throws {
+        logger.info("HTTPClientService started...")
+        try await gracefulShutdown()
+        
+        logger.info("Stopping HTTPClientService...")
+        try await httpClient.shutdown()
+        logger.info("HTTPClientService shutdown completed.")
+    }
+    
+    deinit {
+        try? httpClient.syncShutdown()
+    }
+}

Sources/BreezeLambdaWebHook/BreezeLambdaWebHook.swift

@@ -18,10 +18,6 @@ import class Foundation.JSONEncoder
 
 public extension APIGatewayV2Response {
     private static let encoder = JSONEncoder()
-    
-    /// defaultHeaders
-    /// Override the headers in APIGatewayV2Response
-    static var defaultHeaders = [ "Content-Type": "application/json" ]
 
     struct BodyError: Codable {
         public let error: String
@@ -40,14 +36,19 @@ public extension APIGatewayV2Response {
     /// - Parameters:
     ///   - object: Encodable Object
     ///   - statusCode: HTTP Status Code
-    init<Output: Encodable>(with object: Output, statusCode: HTTPResponse.Status) {
+    ///   - headers: HTTP Headers
+    init<Output: Encodable>(
+        with object: Output,
+        statusCode: HTTPResponse.Status,
+        headers: [String: String] = [ "Content-Type": "application/json" ]
+    ) {
         var body = "{}"
         if let data = try? Self.encoder.encode(object) {
             body = String(data: data, encoding: .utf8) ?? body
         }
         self.init(
             statusCode: statusCode,
-            headers: APIGatewayV2Response.defaultHeaders,
+            headers: headers,
             body: body,
             isBase64Encoded: false
         )

Sources/BreezeLambdaWebHook/APIGatewayV2Request+Extensions.swift renamed to Sources/BreezeLambdaWebHookService/APIGatewayV2Request+Extensions.swift

@@ -15,13 +15,12 @@
 import AsyncHTTPClient
 import AWSLambdaEvents
 import AWSLambdaRuntime
-import AWSLambdaRuntimeCore
 import Foundation
 
-public protocol BreezeLambdaWebHookHandler {
+public protocol BreezeLambdaWebHookHandler: LambdaHandler {
     var handlerContext: HandlerContext { get }
     init(handlerContext: HandlerContext)
-    func handle(context: AWSLambdaRuntimeCore.LambdaContext, event: APIGatewayV2Request) async -> APIGatewayV2Response
+    func handle(_ event: APIGatewayV2Request, context: LambdaContext) async throws -> APIGatewayV2Response
 }
 
 public extension BreezeLambdaWebHookHandler {