Refactor code to be more robust and more swift-like. (#4)

- Ensure we fail all promises when the Channel is closed or we receive an error to prevent any promise leaks.
- Replace class by enum to ensure people not init it by mistake
- Use struct where class is not needed.

Author: normanmaurer

Sources/SwiftAwsLambda/HttpClient.swift

@@ -240,12 +240,26 @@ private class UnaryHTTPHandler: ChannelInboundHandler, ChannelOutboundHandler {
     }
 
     func errorCaught(ctx: ChannelHandlerContext, error: Error) {
-        let promise = buffer.removeFirst()
-        promise.fail(error: error)
+        // In HTTP we should fail all promises as we close the Channel.
+        self.failAllPromises(error: error)
         ctx.close(promise: nil)
     }
+    
+    func channelInactive(ctx: ChannelHandlerContext) {
+        // Fail all promises
+        self.failAllPromises(error: HTTPClientError.connectionClosed)
+        ctx.fireChannelInactive()
+    }
+    
+    private func failAllPromises(error: Error) {
+        while let promise = buffer.first {
+            promise.fail(error: error)
+            buffer.removeFirst()
+        }
+    }
 }
 
 private enum HTTPClientError: Error {
     case invalidRequest
+    case connectionClosed
 }

Sources/SwiftAwsLambda/Lambda+Codable.swift

@@ -15,21 +15,21 @@
 import Foundation
 
 extension Lambda {
-    public class func run<In: Decodable, Out: Encodable>(_ closure: @escaping LambdaCodableClosure<In, Out>) -> LambdaLifecycleResult {
+    public static func run<In: Decodable, Out: Encodable>(_ closure: @escaping LambdaCodableClosure<In, Out>) -> LambdaLifecycleResult {
         return run(LambdaClosureWrapper(closure))
     }
 
-    public class func run<T>(_ handler: T) -> LambdaLifecycleResult where T: LambdaCodableHandler {
+    public static func run<T>(_ handler: T) -> LambdaLifecycleResult where T: LambdaCodableHandler {
         return run(handler as LambdaHandler)
     }
 
     // for testing
-    internal class func run<In: Decodable, Out: Encodable>(closure: @escaping LambdaCodableClosure<In, Out>, maxTimes: Int) -> LambdaLifecycleResult {
+    internal static func run<In: Decodable, Out: Encodable>(closure: @escaping LambdaCodableClosure<In, Out>, maxTimes: Int) -> LambdaLifecycleResult {
         return run(handler: LambdaClosureWrapper(closure), maxTimes: maxTimes)
     }
 
     // for testing
-    internal class func run<T>(handler: T, maxTimes: Int) -> LambdaLifecycleResult where T: LambdaCodableHandler {
+    internal static func run<T>(handler: T, maxTimes: Int) -> LambdaLifecycleResult where T: LambdaCodableHandler {
         return run(handler: handler as LambdaHandler, maxTimes: maxTimes)
     }
 }
@@ -80,6 +80,7 @@ public extension LambdaCodableHandler {
     }
 }
 
+// This is a class as encoder amd decoder are a class, which means its cheaper to hold a reference to both in a class then a struct. 
 private class LambdaCodableJsonCodec<In: Decodable, Out: Encodable>: LambdaCodableCodec<In, Out> {
     private let encoder = JSONEncoder()
     private let decoder = JSONDecoder()
@@ -92,7 +93,7 @@ private class LambdaCodableJsonCodec<In: Decodable, Out: Encodable>: LambdaCodab
     }
 }
 
-private class LambdaClosureWrapper<In: Decodable, Out: Encodable>: LambdaCodableHandler {
+private struct LambdaClosureWrapper<In: Decodable, Out: Encodable>: LambdaCodableHandler {
     typealias Codec = LambdaCodableJsonCodec<In, Out>
 
     private let closure: LambdaCodableClosure<In, Out>

Sources/SwiftAwsLambda/Lambda+String.swift

@@ -13,21 +13,21 @@
 //===----------------------------------------------------------------------===//
 
 extension Lambda {
-    public class func run(_ closure: @escaping LambdaStringClosure) -> LambdaLifecycleResult {
+    public static func run(_ closure: @escaping LambdaStringClosure) -> LambdaLifecycleResult {
         return run(LambdaClosureWrapper(closure))
     }
 
-    public class func run(_ handler: LambdaStringHandler) -> LambdaLifecycleResult {
+    public static func run(_ handler: LambdaStringHandler) -> LambdaLifecycleResult {
         return run(handler as LambdaHandler)
     }
 
     // for testing
-    internal class func run(closure: @escaping LambdaStringClosure, maxTimes: Int) -> LambdaLifecycleResult {
+    internal static func run(closure: @escaping LambdaStringClosure, maxTimes: Int) -> LambdaLifecycleResult {
         return run(handler: LambdaClosureWrapper(closure), maxTimes: maxTimes)
     }
 
     // for testing
-    internal class func run(handler: LambdaStringHandler, maxTimes: Int) -> LambdaLifecycleResult {
+    internal static func run(handler: LambdaStringHandler, maxTimes: Int) -> LambdaLifecycleResult {
         return run(handler: handler as LambdaHandler, maxTimes: maxTimes)
     }
 }
@@ -58,7 +58,7 @@ public extension LambdaStringHandler {
     }
 }
 
-private class LambdaClosureWrapper: LambdaStringHandler {
+private struct LambdaClosureWrapper: LambdaStringHandler {
     private let closure: LambdaStringClosure
     init(_ closure: @escaping LambdaStringClosure) {
         self.closure = closure

Sources/SwiftAwsLambda/Lambda.swift

@@ -14,22 +14,22 @@
 
 import NIO
 
-public final class Lambda {
-    public class func run(_ closure: @escaping LambdaClosure) -> LambdaLifecycleResult {
+public enum Lambda {
+    public static func run(_ closure: @escaping LambdaClosure) -> LambdaLifecycleResult {
         return run(LambdaClosureWrapper(closure))
     }
 
-    public class func run(_ handler: LambdaHandler) -> LambdaLifecycleResult {
+    public static func run(_ handler: LambdaHandler) -> LambdaLifecycleResult {
         return Lifecycle(handler: handler).start()
     }
 
     // for testing
-    internal class func run(closure: @escaping LambdaClosure, maxTimes: Int) -> LambdaLifecycleResult {
+    internal static func run(closure: @escaping LambdaClosure, maxTimes: Int) -> LambdaLifecycleResult {
         return run(handler: LambdaClosureWrapper(closure), maxTimes: maxTimes)
     }
 
     // for testing
-    internal class func run(handler: LambdaHandler, maxTimes: Int) -> LambdaLifecycleResult {
+    internal static func run(handler: LambdaHandler, maxTimes: Int) -> LambdaLifecycleResult {
         return Lifecycle(handler: handler, maxTimes: maxTimes).start()
     }
 
@@ -38,7 +38,7 @@ public final class Lambda {
         private let max: Int
         private var counter: Int = 0
 
-        public init(handler: LambdaHandler, maxTimes: Int = 0) {
+        init(handler: LambdaHandler, maxTimes: Int = 0) {
             self.handler = handler
             max = maxTimes
             assert(max >= 0)
@@ -87,7 +87,7 @@ public struct LambdaContext {
     public let deadlineNs: String?
 }
 
-private class LambdaClosureWrapper: LambdaHandler {
+private struct LambdaClosureWrapper: LambdaHandler {
     private let closure: LambdaClosure
     init(_ closure: @escaping LambdaClosure) {
         self.closure = closure