Lambda runtime v2 (#42)

* New lambda structure similar to server

* Comments, deleted commented code

* Use APIGatewayV2

* Add LambdaRuntimeService

* Add LambdaRuntimeService

* Remove logger from LambdaRuntimeService

* update comment

* Require swift 6

* Use cancellable lambda runtime

* Fix up runtime for latest changes

* Update README

* Add LambdaFunction.beforeLambdaStarts()

* Use lambda runtime v2 beta

* Remove Foundation imports

Author: adam-fowler

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     timeout-minutes: 15
     strategy:
       matrix:
-        image: ["swift:5.10", "swift:6.0", "swift:6.1", "swiftlang/swift:nightly-6.2-noble"]
+        image: ["swift:6.0", "swift:6.1", "swiftlang/swift:nightly-6.2-noble"]
     container:
       image: ${{ matrix.image }}
     steps:

Package.swift

@@ -1,23 +1,23 @@
-// swift-tools-version:5.9
+// swift-tools-version:6.0
 
 import PackageDescription
 
 let package = Package(
     name: "hummingbird-lambda",
     platforms: [
-        .macOS(.v14)
+        .macOS(.v15)
     ],
     products: [
         .library(name: "HummingbirdLambda", targets: ["HummingbirdLambda"]),
         .library(name: "HummingbirdLambdaTesting", targets: ["HummingbirdLambdaTesting"]),
         .executable(name: "HBLambdaTest", targets: ["HBLambdaTest"]),
     ],
     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-runtime.git", from: "2.0.0-beta"),
         .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "1.0.0"),
         .package(url: "https://github.com/swift-extras/swift-extras-base64.git", from: "1.0.0"),
-        .package(url: "https://github.com/hummingbird-project/hummingbird.git", from: "2.0.0"),
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.32.0"),
+        .package(url: "https://github.com/hummingbird-project/hummingbird.git", from: "2.9.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.81.0"),
     ],
     targets: [
         .target(

README.md

@@ -4,23 +4,15 @@ Run Hummingbird inside an AWS Lambda
 
 ## Usage
 
-Create struct conforming to `LambdaFunction`. Setup your application in the `init` function: add your middleware, add route handlers etc
-
 ```swift
-@main
-struct MyHandler: LambdaFunction {
-    // define input and output
-    typealias Event = APIGatewayRequest
-    typealias Output = APIGatewayResponse
-    typealias Context = BasicLambdaRequestContext<APIGatewayRequest>
- 
-    init(_ app: Application) {
-        app.middleware.add(LogRequestsMiddleware(.debug))
-        app.router.get("hello") { _, _ in
-            return "Hello"
-        }
-    }
+typealias AppRequestContext = BasicLambdaRequestContext<APIGatewayV2Request>
+
+// Create router and add a single route returning "Hello" in its body
+let router = Router(context: AppRequestContext.self)
+router.get("hello") { _, _ in
+    return "Hello"
 }
+// create lambda using router and run
+let lambda = APIGatewayV2LambdaFunction(router: router)
+try await lambda.runService()
 ```
-
-The `Event` and `Output` types define your input and output objects. If you are using an `APIGateway` REST interface to invoke your Lambda then set these to `APIGatewayRequest` and `APIGatewayResponse` respectively. If you are using an `APIGateway` HTML interface then set these to `APIGatewayV2Request` and `APIGatewayV2Response`. If you are using any other `Event`/`Output` types you will need to implement the `request(context:application:from:)` and `output(from:)` methods yourself.

Sources/HBLambdaTest/maths.swift

@@ -18,8 +18,10 @@ import Hummingbird
 import HummingbirdLambda
 import Logging
 
+typealias AppRequestContext = BasicLambdaRequestContext<APIGatewayV2Request>
+
 struct DebugMiddleware: RouterMiddleware {
-    typealias Context = MathsHandler.Context
+    typealias Context = AppRequestContext
     func handle(
         _ request: Request,
         context: Context,
@@ -32,42 +34,34 @@ struct DebugMiddleware: RouterMiddleware {
     }
 }
 
-@main
-struct MathsHandler: APIGatewayLambdaFunction {
-    typealias Context = BasicLambdaRequestContext<APIGatewayRequest>
-
-    struct Operands: Decodable {
-        let lhs: Double
-        let rhs: Double
-    }
-
-    struct Result: ResponseEncodable {
-        let result: Double
-    }
-
-    init(context: LambdaInitializationContext) {}
+struct Operands: Decodable {
+    let lhs: Double
+    let rhs: Double
+}
 
-    func buildResponder() -> some HTTPResponder<Context> {
-        let router = Router(context: Context.self)
-        router.middlewares.add(DebugMiddleware())
-        router.post("add") { request, context -> Result in
-            let operands = try await request.decode(as: Operands.self, context: context)
-            return Result(result: operands.lhs + operands.rhs)
-        }
-        router.post("subtract") { request, context -> Result in
-            let operands = try await request.decode(as: Operands.self, context: context)
-            return Result(result: operands.lhs - operands.rhs)
-        }
-        router.post("multiply") { request, context -> Result in
-            let operands = try await request.decode(as: Operands.self, context: context)
-            return Result(result: operands.lhs * operands.rhs)
-        }
-        router.post("divide") { request, context -> Result in
-            let operands = try await request.decode(as: Operands.self, context: context)
-            return Result(result: operands.lhs / operands.rhs)
-        }
-        return router.buildResponder()
-    }
+struct Result: ResponseEncodable {
+    let result: Double
+}
 
-    func shutdown() async throws {}
+let router = Router(context: AppRequestContext.self)
+router.middlewares.add(DebugMiddleware())
+router.post("add") { request, context -> Result in
+    let operands = try await request.decode(as: Operands.self, context: context)
+    return Result(result: operands.lhs + operands.rhs)
+}
+router.post("subtract") { request, context -> Result in
+    let operands = try await request.decode(as: Operands.self, context: context)
+    return Result(result: operands.lhs - operands.rhs)
+}
+router.post("multiply") { request, context -> Result in
+    let operands = try await request.decode(as: Operands.self, context: context)
+    return Result(result: operands.lhs * operands.rhs)
+}
+router.post("divide") { request, context -> Result in
+    let operands = try await request.decode(as: Operands.self, context: context)
+    return Result(result: operands.lhs / operands.rhs)
 }
+let lambda = APIGatewayV2LambdaFunction(
+    router: router
+)
+try await lambda.runService()

Sources/HummingbirdLambda/APIGatewayLambda.swift

@@ -13,48 +13,13 @@
 //===----------------------------------------------------------------------===//
 
 import AWSLambdaEvents
-import AWSLambdaRuntimeCore
 import Hummingbird
 import NIOCore
 import NIOHTTP1
 
-/// Protocol for Hummingbird Lambdas that use APIGateway
-///
-/// With this protocol you no longer need to set the `Event` and `Output`
-/// associated values.
-/// ```swift
-/// struct MyLambda: APIGatewayLambda {
-///     typealias Context = MyLambdaRequestContext
-///
-///     init(context: LambdaInitializationContext) {}
-///
-///     /// build responder that will create a response from a request
-///     func buildResponder() -> some Responder<Context> {
-///         let router = Router(context: Context.self)
-///         router.get("hello") { _,_ in
-///             "Hello"
-///         }
-///         return router.buildResponder()
-///     }
-/// }
-/// ```
-public protocol APIGatewayLambdaFunction: LambdaFunction where Event == APIGatewayRequest, Output == APIGatewayResponse {
-    associatedtype Context = BasicLambdaRequestContext<APIGatewayRequest>
-}
-
-extension LambdaFunction where Event == APIGatewayRequest {
-    /// Specialization of Lambda.request where `Event` is `APIGatewayRequest`
-    public func request(context: LambdaContext, from: Event) throws -> Request {
-        try Request(context: context, from: from)
-    }
-}
-
-extension LambdaFunction where Output == APIGatewayResponse {
-    /// Specialization of Lambda.request where `Output` is `APIGatewayResponse`
-    public func output(from response: Response) async throws -> Output {
-        try await response.apiResponse()
-    }
-}
+/// Typealias for Lambda function triggered by APIGateway
+public typealias APIGatewayLambdaFunction<Responder: HTTPResponder> = LambdaFunction<Responder, APIGatewayRequest, APIGatewayResponse>
+where Responder.Context: InitializableFromSource<LambdaRequestContextSource<APIGatewayRequest>>
 
 // conform `APIGatewayRequest` to `APIRequest` so we can use Request.init(context:application:from)
 extension APIGatewayRequest: APIRequest {

Sources/HummingbirdLambda/APIGatewayV2Lambda.swift

@@ -13,48 +13,13 @@
 //===----------------------------------------------------------------------===//
 
 import AWSLambdaEvents
-import AWSLambdaRuntimeCore
 import Hummingbird
 import NIOCore
 import NIOHTTP1
 
-/// Protocol for Hummingbird Lambdas that use APIGatewayV2
-///
-/// With this protocol you no longer need to set the `Event` and `Output`
-/// associated values.
-/// ```swift
-/// struct MyLambda: APIGatewayLambda {
-///     typealias Context = MyLambdaRequestContext
-///
-///     init(context: LambdaInitializationContext) {}
-///
-///     /// build responder that will create a response from a request
-///     func buildResponder() -> some Responder<Context> {
-///         let router = Router(context: Context.self)
-///         router.get("hello") { _,_ in
-///             "Hello"
-///         }
-///         return router.buildResponder()
-///     }
-/// }
-/// ```
-public protocol APIGatewayV2LambdaFunction: LambdaFunction where Event == APIGatewayV2Request, Output == APIGatewayV2Response {
-    associatedtype Context = BasicLambdaRequestContext<APIGatewayV2Request>
-}
-
-extension LambdaFunction where Event == APIGatewayV2Request {
-    /// Specialization of Lambda.request where `Event` is `APIGatewayV2Request`
-    public func request(context: LambdaContext, from: Event) throws -> Request {
-        try Request(context: context, from: from)
-    }
-}
-
-extension LambdaFunction where Output == APIGatewayV2Response {
-    /// Specialization of Lambda.request where `Output` is `APIGatewayV2Response`
-    public func output(from response: Response) async throws -> Output {
-        try await response.apiResponse()
-    }
-}
+/// Typealias for Lambda function triggered by APIGatewayV2
+public typealias APIGatewayV2LambdaFunction<Responder: HTTPResponder> = LambdaFunction<Responder, APIGatewayV2Request, APIGatewayV2Response>
+where Responder.Context: InitializableFromSource<LambdaRequestContextSource<APIGatewayV2Request>>
 
 // conform `APIGatewayV2Request` to `APIRequest` so we can use Request.init(context:application:from)
 extension APIGatewayV2Request: APIRequest {

Sources/HummingbirdLambda/BasicLambdaRequestContext.swift

@@ -12,8 +12,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import AWSLambdaRuntimeCore
-import Foundation
 import Hummingbird
 import Logging
 import NIOCore

Sources/HummingbirdLambda/Deprecations.swift

@@ -16,12 +16,8 @@
 // temporarily to ease transition from the old symbols that included the "HB"
 // prefix to the new ones.
 
-@_documentation(visibility: internal) @available(*, unavailable, renamed: "LambdaFunction")
-public typealias HBLambda = LambdaFunction
-@_documentation(visibility: internal) @available(*, unavailable, renamed: "APIGatewayLambdaFunction")
-public typealias HBAPIGatewayLambda = APIGatewayLambdaFunction
-@_documentation(visibility: internal) @available(*, unavailable, renamed: "APIGatewayV2LambdaFunction")
-public typealias HBAPIGatewayV2Lambda = APIGatewayV2LambdaFunction
+@_documentation(visibility: internal) @available(*, unavailable, renamed: "LambdaFunctionProtocol")
+public typealias HBLambda = LambdaFunctionProtocol
 @_documentation(visibility: internal) @available(*, unavailable, renamed: "LambdaRequestContext")
 public typealias HBLambdaRequestContext = LambdaRequestContext
 @_documentation(visibility: internal) @available(*, unavailable, renamed: "BasicLambdaRequestContext")