Support launching a HBMixedLambdaApplication as either HTTP or Lambda

Sources/HBLambdaTest/maths.swift

@@ -27,14 +27,24 @@ struct DebugMiddleware: HBMiddlewareProtocol {
         next: (HBRequest, Context) async throws -> Output
     ) async throws -> Output {
         context.logger.debug("\(request.method) \(request.uri)")
-        context.logger.debug("\(context.event)")
+
+        switch context {
+        case .lambda(let context):
+            context.logger.debug("\(context.event)")
+        case .http(let context):
+            context.logger.debug("HTTP Event \(context.id)")
+        }
 
         return try await next(request, context)
     }
 }
 
 @main
-struct MathsHandler: HBAPIGatewayLambda {
+struct MathsHandler: HBMixedLambdaApplication {
+    typealias Event = APIGatewayRequest
+    typealias Output = APIGatewayResponse
+    typealias Context = HBBasicMixedLambdaContext<Event>
+
     struct Operands: Decodable {
         let lhs: Double
         let rhs: Double
@@ -44,7 +54,18 @@ struct MathsHandler: HBAPIGatewayLambda {
         let result: Double
     }
 
+    static var hostingMode: HostingMode {
+        get throws {
+            if try HBEnvironment.dotEnv().get("SERVE_HTTP", as: Bool.self) == true {
+                return .server
+            } else {
+                return .lambda
+            }
+        }
+    }
+
     init(context: LambdaInitializationContext) {}
+    init() {}
 
     func buildResponder() -> some HBResponder<Context> {
         let router = HBRouter(context: Context.self)

Sources/HummingbirdLambda/Lambda.swift

@@ -83,7 +83,4 @@ extension HBLambda {
     }
 
     public func shutdown() async throws {}
-
-    /// default configuration
-    public var configuration: HBApplicationConfiguration { .init() }
 }

Sources/HummingbirdLambda/MixedLambdaApplication.swift

@@ -0,0 +1,66 @@
+import Hummingbird
+import AWSLambdaRuntime
+import Logging
+import NIOCore
+import NIOPosix
+
+public enum HBBasicMixedLambdaContext<Event: Sendable>: HBLambdaRequestContext, HBRequestContext {
+    case lambda(HBBasicLambdaRequestContext<Event>)
+    case http(HBBasicRequestContext)
+
+    public var coreContext: HBCoreRequestContext {
+        get {
+            switch self {
+            case .lambda(let context):
+                return context.coreContext
+            case .http(let context):
+                return context.coreContext
+            }
+        }
+        set {
+            switch self {
+            case .lambda(var context):
+                context.coreContext = newValue
+                self = .lambda(context)
+            case .http(var context):
+                context.coreContext = newValue
+                self = .http(context)
+            }
+        }
+    }
+
+    public init(_ event: Event, lambdaContext: LambdaContext) {
+        self = .lambda(HBBasicLambdaRequestContext(event, lambdaContext: lambdaContext))
+    }
+
+    public init(allocator: ByteBufferAllocator, logger: Logger) {
+        self = .http(HBBasicRequestContext(allocator: allocator, logger: logger))
+    }
+
+    public init(channel: any Channel, logger: Logger) {
+        self = .http(HBBasicRequestContext(channel: channel, logger: logger))
+    }
+}
+
+public protocol HBMixedLambdaApplication: HBLambda, HBApplicationProtocol where Context: HBLambdaRequestContext<Event> & HBRequestContext {
+    static var hostingMode: HostingMode { get async throws }
+
+    init()
+}
+
+public enum HostingMode {
+    case lambda, server
+}
+
+extension HBMixedLambdaApplication {
+    public static func main() async throws {
+        switch try await Self.hostingMode {
+        case .lambda:
+            HBLambdaHandler<Self>.main()
+        case .server:
+            try await Self().runService()
+        }
+    }
+
+    public var responder: Responder { buildResponder() }
+}