Merge branch 'main' into main

Author: sebsto

.github/workflows/pull_request.yml

@@ -4,6 +4,9 @@ on:
   pull_request:
     types: [opened, reopened, synchronize]
 
+# As per Checkov CKV2_GHA_1
+permissions: read-all
+
 jobs:
   soundness:
     name: Soundness
@@ -23,7 +26,7 @@ jobs:
     with:
       linux_5_9_enabled: false
       linux_5_10_enabled: false
-      linux_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error"
+      linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error"
       linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
 
   swift-6-language-mode:

.gitignore

@@ -10,3 +10,5 @@ xcuserdata
 Package.resolved
 .serverless
 .devcontainer
+.amazonq
+.ash

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.8
+// swift-tools-version:6.0
 
 import PackageDescription
 

[email protected]

@@ -0,0 +1,26 @@
+// swift-tools-version:5.10
+
+import PackageDescription
+
+let swiftSettings: [SwiftSetting] = [.enableExperimentalFeature("StrictConcurrency=complete")]
+
+let package = Package(
+    name: "swift-aws-lambda-events",
+    platforms: [.macOS(.v14)],
+    products: [
+        .library(name: "AWSLambdaEvents", targets: ["AWSLambdaEvents"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-http-types.git", from: "1.0.0"),
+    ],
+    targets: [
+        .target(
+            name: "AWSLambdaEvents",
+            dependencies: [
+                .product(name: "HTTPTypes", package: "swift-http-types")
+            ],
+            swiftSettings: swiftSettings
+        )
+    ]
+)

Sources/AWSLambdaEvents/APIGateway+V2.swift

@@ -126,6 +126,8 @@ public struct APIGatewayV2Request: Encodable, Sendable {
     }
 }
 
+extension APIGatewayV2Request: DecodableRequest {}
+
 public struct APIGatewayV2Response: Codable, Sendable {
     public var statusCode: HTTPResponse.Status
     public var headers: HTTPHeaders?
@@ -148,6 +150,8 @@ public struct APIGatewayV2Response: Codable, Sendable {
     }
 }
 
+extension APIGatewayV2Response: EncodableResponse {}
+
 extension APIGatewayV2Request: Decodable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)

Sources/AWSLambdaEvents/APIGateway+WebSockets.swift

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) YEARS 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
+//
+//===----------------------------------------------------------------------===//
+
+/// `APIGatewayWebSocketRequest` is a variation of the`APIGatewayV2Request`
+/// and contains data coming from the WebSockets API Gateway.
+public struct APIGatewayWebSocketRequest: Codable {
+    /// `Context` contains information to identify the AWS account and resources invoking the Lambda function.
+    public struct Context: Codable {
+        public struct Identity: Codable {
+            public let sourceIp: String
+        }
+
+        public let routeKey: String
+        public let eventType: String
+        public let extendedRequestId: String
+        /// The request time in format: 23/Apr/2020:11:08:18 +0000
+        public let requestTime: String
+        public let messageDirection: String
+        public let stage: String
+        public let connectedAt: UInt64
+        public let requestTimeEpoch: UInt64
+        public let identity: Identity
+        public let requestId: String
+        public let domainName: String
+        public let connectionId: String
+        public let apiId: String
+    }
+
+    public let headers: HTTPHeaders?
+    public let multiValueHeaders: HTTPMultiValueHeaders?
+    public let context: Context
+    public let body: String?
+    public let isBase64Encoded: Bool?
+
+    enum CodingKeys: String, CodingKey {
+        case headers
+        case multiValueHeaders
+        case context = "requestContext"
+        case body
+        case isBase64Encoded
+    }
+}
+
+/// `APIGatewayWebSocketResponse` is a type alias for `APIGatewayV2Request`.
+/// Typically, lambda WebSockets servers send clients data via
+/// the ApiGatewayManagementApi mechanism. However, APIGateway does require
+/// lambda servers to return some kind of status when APIGateway invokes them.
+/// This can be as simple as always returning a 200 "OK" response for all
+/// WebSockets requests (the ApiGatewayManagementApi can return any errors to
+/// WebSockets clients).
+public typealias APIGatewayWebSocketResponse = APIGatewayV2Response
+
+#if swift(>=5.6)
+extension APIGatewayWebSocketRequest: Sendable {}
+extension APIGatewayWebSocketRequest.Context: Sendable {}
+extension APIGatewayWebSocketRequest.Context.Identity: Sendable {}
+#endif

Sources/AWSLambdaEvents/Codable Helpers/DecodableRequest.swift

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2017-2022 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 HTTPTypes
+
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+public protocol DecodableRequest {
+    var body: String? { get }
+    var isBase64Encoded: Bool { get }
+
+    func decodeBody() throws -> Data?
+    func decodeBody<T>(
+        _ type: T.Type,
+        using decoder: JSONDecoder
+    ) throws -> T where T: Decodable
+}
+
+extension DecodableRequest {
+    /// Decodes the body of the request into a `Data` object.
+    ///
+    /// - Returns: The decoded body as `Data` or `nil` if the body is empty.
+    public func decodeBody() throws -> Data? {
+        guard let body else { return nil }
+
+        if isBase64Encoded,
+            let base64Decoded = Data(base64Encoded: body)
+        {
+            return base64Decoded
+        }
+
+        return body.data(using: .utf8)
+    }
+
+    /// Decodes the body of the request into a decodable object. When the
+    /// body is empty, an error is thrown.
+    ///
+    /// - Parameters:
+    ///   - type: The type to decode the body into.
+    ///   - decoder: The decoder to use. Defaults to `JSONDecoder()`.
+    ///
+    /// - Returns: The decoded body as `T`.
+    /// - Throws: An error if the body cannot be decoded.
+    public func decodeBody<T>(
+        _ type: T.Type,
+        using decoder: JSONDecoder = JSONDecoder()
+    ) throws -> T where T: Decodable {
+        let bodyData = body?.data(using: .utf8) ?? Data()
+
+        var requestData = bodyData
+
+        if isBase64Encoded,
+            let base64Decoded = Data(base64Encoded: requestData)
+        {
+            requestData = base64Decoded
+        }
+
+        return try decoder.decode(T.self, from: requestData)
+    }
+}

Sources/AWSLambdaEvents/Codable Helpers/EncodableResponse.swift

@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2017-2022 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 HTTPTypes
+
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+public protocol EncodableResponse {
+    static func encoding<T>(
+        _ encodable: T,
+        status: HTTPResponse.Status,
+        using encoder: JSONEncoder,
+        headers: HTTPHeaders?,
+        cookies: [String]?,
+        onError: ((Error) -> Self)
+    ) -> Self where T: Encodable
+
+    init(
+        statusCode: HTTPResponse.Status,
+        headers: HTTPHeaders?,
+        body: String?,
+        isBase64Encoded: Bool?,
+        cookies: [String]?
+    )
+}
+
+extension EncodableResponse {
+    /// Encodes a given encodable object into a response object.
+    ///
+    /// - Parameters:
+    ///   - encodable: The object to encode.
+    ///   - status: The status code to use. Defaults to `ok`.
+    ///   - encoder: The encoder to use. Defaults to a new `JSONEncoder`.
+    ///   - onError: A closure to handle errors, and transform them into a `APIGatewayV2Response`.
+    /// Defaults to converting the error into a 500 (Internal Server Error) response with the error message as
+    /// the body.
+    ///
+    /// - Returns: a response object whose body is the encoded `encodable` type and with the
+    /// other response parameters
+    public static func encoding<T>(
+        _ encodable: T,
+        status: HTTPResponse.Status = .ok,
+        using encoder: JSONEncoder = JSONEncoder(),
+        headers: HTTPHeaders? = nil,
+        cookies: [String]? = nil,
+        onError: ((Error) -> Self) = Self.defaultErrorHandler
+    ) -> Self where T: Encodable {
+        do {
+            let encodedResponse = try encoder.encode(encodable)
+            return Self(
+                statusCode: status,
+                headers: headers,
+                body: String(data: encodedResponse, encoding: .utf8),
+                isBase64Encoded: nil,
+                cookies: cookies
+            )
+        } catch {
+            return onError(error)
+        }
+    }
+
+    public static var defaultErrorHandler: ((Error) -> Self) {
+        { error in
+            Self(
+                statusCode: .internalServerError,
+                headers: nil,
+                body: "Internal Server Error: \(String(describing: error))",
+                isBase64Encoded: nil,
+                cookies: nil
+            )
+        }
+    }
+}

Sources/AWSLambdaEvents/Codable Helpers/SQS+Decode.swift

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2017-2022 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
+//
+//===----------------------------------------------------------------------===//
+
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+extension SQSEvent {
+    /// Decodes the records included in the event into an array of decodable objects.
+    ///
+    /// - Parameters:
+    ///   - type: The type to decode the body into.
+    ///   - decoder: The decoder to use. Defaults to a new `JSONDecoder`.
+    ///
+    /// - Returns: The decoded records as `[T]`.
+    /// - Throws: An error if any of the records cannot be decoded.
+    public func decodeBody<T>(
+        _ type: T.Type,
+        using decoder: JSONDecoder = JSONDecoder()
+    ) throws -> [T] where T: Decodable {
+        try records.map {
+            try $0.decodeBody(type, using: decoder)
+        }
+    }
+}
+
+extension SQSEvent.Message {
+    /// Decodes the body of the message into a decodable object.
+    ///
+    /// - Parameters:
+    ///   - type: The type to decode the body into.
+    ///   - decoder: The decoder to use. Defaults to a new `JSONDecoder`.
+    ///
+    /// - Returns: The decoded body as `T`.
+    /// - Throws: An error if the body cannot be decoded.
+    public func decodeBody<T>(
+        _ type: T.Type,
+        using decoder: JSONDecoder = JSONDecoder()
+    ) throws -> T where T: Decodable {
+        try decoder.decode(T.self, from: body.data(using: .utf8) ?? Data())
+    }
+}