Update library to support Swift Lambda runtime v2

Author: sebsto

.gitignore

@@ -1,7 +1,8 @@
 .DS_Store
-/.aws-sam/
-/.build
-/.swiftpm
+.aws-sam/
+.build
+.index-build
+.swiftpm
 samconfig.toml
 Package.resolved
 /*.xcodeproj
@@ -10,4 +11,3 @@ DerivedData/
 .swiftpm/config/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 *key
-

Package.swift

@@ -5,13 +5,12 @@ import PackageDescription
 
 let package = Package(
     name: "swift-openapi-lambda",
-    platforms: [.macOS(.v12)],
+    platforms: [.macOS(.v15)],
     products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "1.0.0"),
-        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.8.2"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "2.0.0-beta.2"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "1.2.0"),
     ],
     targets: [
         .target(
@@ -21,8 +20,7 @@ let package = Package(
                 .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
                 .product(name: "OpenAPIRuntime", package: "swift-openapi-runtime"),
             ],
-            path: "Sources",
-            swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
+            path: "Sources"
         ),
         // test targets
         .testTarget(

[email protected]

@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift OpenAPI Lambda open source project
+//
+// Copyright (c) 2025 Amazon.com, Inc. or its affiliates
+//                    and the Swift OpenAPI Lambda project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift OpenAPI Lambda project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+// re-export AWSLambdaRuntime and AWSLambdaEvents so that users don't have to.
+@_exported import AWSLambdaRuntime
+@_exported import AWSLambdaEvents

[email protected]

@@ -14,11 +14,12 @@
 //===----------------------------------------------------------------------===//
 import Foundation
 import AWSLambdaRuntime
+import Logging
 import OpenAPIRuntime
 import HTTPTypes
 
 /// A Lambda function implemented with a OpenAPI server (implementing `APIProtocol` from Swift OpenAPIRuntime)
-public protocol OpenAPILambda {
+public protocol OpenAPILambda: Sendable {
 
     associatedtype Event: Decodable
     associatedtype Output: Encodable
@@ -40,10 +41,19 @@ public protocol OpenAPILambda {
 }
 
 extension OpenAPILambda {
-    /// Initializes and runs the Lambda function.
-    ///
-    /// If you precede your ``EventLoopLambdaHandler`` conformer's declaration with the
-    /// [@main](https://docs.swift.org/swift-book/ReferenceManual/Attributes.html#ID626)
-    /// attribute, the system calls the conformer's `main()` method to launch the lambda function.
-    public static func main() throws { OpenAPILambdaHandler<Self>.main() }
+    /// Returns the Lambda handler function for this OpenAPI Lambda implementation.
+    /// - Returns: A handler function that can be used with AWS Lambda Runtime
+    public static func handler() throws -> (Event, LambdaContext) async throws -> Output {
+        try OpenAPILambdaHandler<Self>().handler
+    }
+
+    /// Start the Lambda Runtime with the Lambda handler function for this OpenAPI Lambda implementation with a custom logger,
+    /// when one is given.
+    /// - Parameter logger: The logger to use for Lambda runtime logging
+    public static func run(logger: Logger? = nil) async throws {
+
+        let _logger = logger ?? Logger(label: "OpenAPILambda")
+        let lambdaRuntime = try LambdaRuntime(logger: _logger, body: Self.handler())
+        try await lambdaRuntime.run()
+    }
 }

Sources/Exports.swift

@@ -18,7 +18,11 @@ import OpenAPIRuntime
 import HTTPTypes
 
 /// Specialization of LambdaHandler which runs an OpenAPILambda
-public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
+struct OpenAPILambdaHandler<L: OpenAPILambda> {
+
+    private let router: OpenAPILambdaRouter
+    private let transport: OpenAPILambdaTransport
+    private let lambda: L
 
     /// the input type for this Lambda handler (received from the `OpenAPILambda`)
     public typealias Event = L.Event
@@ -31,7 +35,7 @@ public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
     /// Create application, set it up and create `OpenAPILambda` from application and create responder
     /// - Parameters
     ///   - context: Lambda initialization context
-    public init(context: LambdaInitializationContext) throws {
+    init() throws {
         self.router = TrieRouter()
         self.transport = OpenAPILambdaTransport(router: self.router)
         self.lambda = try .init(transport: self.transport)
@@ -45,17 +49,17 @@ public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
     ///     - context: Runtime ``LambdaContext``.
     ///
     /// - Returns: A Lambda result ot type `Output`.
-    public func handle(_ request: Event, context: LambdaContext) async throws -> Output {
+    func handler(event: L.Event, context: LambdaContext) async throws -> L.Output {
 
-        // by default return HTTP 500
+        // by default returns HTTP 500
         var lambdaResponse: OpenAPILambdaResponse = (HTTPResponse(status: .internalServerError), "unknown error")
 
         do {
             // convert Lambda event source to OpenAPILambdaRequest
-            let request = try lambda.request(context: context, from: request)
+            let request = try lambda.request(context: context, from: event)
 
             // route the request to find the handlers and extract the paramaters
-            let (handler, parameters) = try await router.route(method: request.0.method, path: request.0.path!)
+            let (handler, parameters) = try router.route(method: request.0.method, path: request.0.path!)
 
             // call the request handler (and extract the HTTPRequest and HTTPBody)
             let httpRequest = request.0
@@ -103,8 +107,4 @@ public struct OpenAPILambdaHandler<L: OpenAPILambda>: LambdaHandler {
         // transform the OpenAPILambdaResponse to the Lambda Output
         return lambda.output(from: lambdaResponse)
     }
-
-    let router: OpenAPILambdaRouter
-    let transport: OpenAPILambdaTransport
-    let lambda: L
 }

Sources/OpenAPILambda.swift

@@ -30,17 +30,17 @@ public typealias OpenAPILambdaResponse = (HTTPResponse, String?)
 public typealias OpenAPILambdaRequestParameters = [String: Substring]
 
 /// an OpenAPI handler
-public typealias OpenAPIHandler = @Sendable (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
+public typealias OpenAPIHandler = (HTTPRequest, HTTPBody?, ServerRequestMetadata) async throws -> (
     HTTPResponse, HTTPBody?
 )
 
 /// Lambda Transport for OpenAPI generator
 public struct OpenAPILambdaTransport: ServerTransport {
 
-    private var router: OpenAPILambdaRouter
+    private let router: OpenAPILambdaRouter
 
     /// Create a `OpenAPILambdaTransport` with the given `OpenAPILambdaRouter`
-    public init(router: OpenAPILambdaRouter) { self.router = router }
+    init(router: OpenAPILambdaRouter) { self.router = router }
 
     /// Registers an HTTP operation handler at the provided path and method.
     /// - Parameters:

Sources/OpenAPILambdaHandler.swift

@@ -24,12 +24,12 @@ public enum OpenAPILambdaRouterError: Error {
 }
 
 /// A router API
-public protocol OpenAPILambdaRouter {
+protocol OpenAPILambdaRouter {
     /// add a route for a given HTTP method and path and associate a handler
     func add(method: HTTPRequest.Method, path: String, handler: @escaping OpenAPIHandler) throws
 
     /// Retrieve the handler and path parameter for a given HTTP method and path
-    func route(method: HTTPRequest.Method, path: String) async throws -> (
+    func route(method: HTTPRequest.Method, path: String) throws -> (
         OpenAPIHandler, OpenAPILambdaRequestParameters
     )
 }

Sources/OpenAPILambdaTransport.swift

@@ -22,24 +22,24 @@ import HTTPTypes
 /// - a path element (represented as a `String`),
 /// - a path parameter (represented as a `String`)
 /// - a handler, only for leaf nodes (represented as `OpenAPIHandler`)
-class Node {
+final class Node {
     let value: NodeValue
     var children: [String: Node] = [:]
 
     /// Default init, create a root node
-    public init() { value = .root }
+    init() { value = .root }
 
     /// Creates a node for an HTTP method
-    public init(httpMethod: HTTPRequest.Method) { value = .httpMethod(httpMethod) }
+    init(httpMethod: HTTPRequest.Method) { value = .httpMethod(httpMethod) }
 
     /// Creates a node for a path element
-    public init(pathElement: String) { value = .pathElement(pathElement) }
+    init(pathElement: String) { value = .pathElement(pathElement) }
 
     /// Creates a node for a path parameter
-    public init(parameterName: String) { value = .pathParameter(parameterName) }
+    init(parameterName: String) { value = .pathParameter(parameterName) }
 
     /// Creates a node for an OpenAPI handler
-    public init(handler: @escaping OpenAPIHandler) { value = .handler(handler) }
+    init(handler: @escaping OpenAPIHandler) { value = .handler(handler) }
 
     /// Creates a node for an existing node value
     private init(value: NodeValue) { self.value = value }
@@ -62,8 +62,8 @@ class Node {
     /// - Throws:
     ///   - URIPathCollectionError.canNotAddChildToHandlerNode when trying to add a child to leaf node of type `.handler`
     ///   - URIPathCollectionError.canNotHaveMultipleParamChilds when trying to add multiple child node of type `.parameter`
-
     func add(pathElement: String) throws -> Node { try add(child: NodeValue.pathElement(pathElement)) }
+
     /// Convenience method to add a child node of type path parameter  to this node
     /// - Parameter:
     ///     - pathParameter: the name of a path parameter. A path parameter is a `{name}` usually found between `/` characters in the URI
@@ -72,8 +72,8 @@ class Node {
     /// - Throws:
     ///   - URIPathCollectionError.canNotAddChildToHandlerNode when trying to add a child to leaf node of type `.handler`
     ///   - URIPathCollectionError.canNotHaveMultipleParamChilds when trying to add multiple child node of type `.parameter`
-
     func add(parameter: String) throws -> Node { try add(child: NodeValue.pathParameter(parameter)) }
+
     /// Convenience method to add a child node of type handler to this node
     /// - Parameter:
     ///     - handler: a function handler. A handler MUST be a leaf node (it has no children) and is of type `OpenAPIHandler`