use type system

Author: tomerd

Package.swift

@@ -4,6 +4,7 @@ import PackageDescription
 
 let package = Package(
     name: "swift-aws-lambda-runtime",
+    platforms: [ .macOS(.v10_15) ],
     products: [
         // this library exports `AWSLambdaRuntimeCore` and adds Foundation convenience methods
         .library(name: "AWSLambdaRuntime", targets: ["AWSLambdaRuntime"]),

[email protected]

@@ -1,4 +1,4 @@
-// swift-tools-version:5.4
+// swift-tools-version:5.5
 
 import PackageDescription
 

[email protected] renamed to [email protected]

@@ -1,4 +1,4 @@
-// swift-tools-version:5.4
+// swift-tools-version:5.6
 
 import PackageDescription
 

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -21,7 +21,6 @@ import NIOFoundationCompat
 
 // MARK: - LambdaHandler Codable support
 
-#if compiler(>=5.5) && canImport(_Concurrency)
 /// Implementation of  a`ByteBuffer` to `Event` decoding.
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 extension LambdaHandler where Event: Decodable {
@@ -35,8 +34,8 @@ extension LambdaHandler where Event: Decodable {
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 extension LambdaHandler where Output: Encodable {
     @inlinable
-    public func encode(allocator: ByteBufferAllocator, value: Output) throws -> ByteBuffer? {
-        try self.encoder.encode(value, using: allocator)
+    public func encode(value: Output, into buffer: inout ByteBuffer) throws {
+        try self.encoder.encode(value, into: &buffer)
     }
 }
 
@@ -57,7 +56,6 @@ extension LambdaHandler where Output: Encodable {
         Lambda.defaultJSONEncoder
     }
 }
-#endif
 
 // MARK: - EventLoopLambdaHandler Codable support
 
@@ -72,8 +70,8 @@ extension EventLoopLambdaHandler where Event: Decodable {
 /// Implementation of  `Output` to `ByteBuffer` encoding.
 extension EventLoopLambdaHandler where Output: Encodable {
     @inlinable
-    public func encode(allocator: ByteBufferAllocator, value: Output) throws -> ByteBuffer? {
-        try self.encoder.encode(value, using: allocator)
+    public func encode(value: Output, into buffer: inout ByteBuffer) throws {
+        try self.encoder.encode(value, into: &buffer)
     }
 }
 
@@ -98,7 +96,7 @@ public protocol LambdaCodableDecoder {
 }
 
 public protocol LambdaCodableEncoder {
-    func encode<T: Encodable>(_ value: T, using allocator: ByteBufferAllocator) throws -> ByteBuffer
+    func encode<T: Encodable>(_ value: T, into buffer: inout ByteBuffer) throws
 }
 
 extension Lambda {
@@ -108,11 +106,4 @@ extension Lambda {
 
 extension JSONDecoder: LambdaCodableDecoder {}
 
-extension JSONEncoder: LambdaCodableEncoder {
-    public func encode<T>(_ value: T, using allocator: ByteBufferAllocator) throws -> ByteBuffer where T: Encodable {
-        // nio will resize the buffer if necessary
-        var buffer = allocator.buffer(capacity: 1024)
-        try self.encode(value, into: &buffer)
-        return buffer
-    }
-}
+extension JSONEncoder: LambdaCodableEncoder {}

Sources/AWSLambdaRuntimeCore/Lambda+String.swift

@@ -13,25 +13,46 @@
 //===----------------------------------------------------------------------===//
 import NIOCore
 
-extension EventLoopLambdaHandler where Event == String {
+// MARK: - LambdaHandler String support
+
+@available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
+extension LambdaHandler where Event == String {
     /// Implementation of a `ByteBuffer` to `String` decoding.
     @inlinable
     public func decode(buffer: ByteBuffer) throws -> String {
-        var buffer = buffer
-        guard let string = buffer.readString(length: buffer.readableBytes) else {
-            fatalError("buffer.readString(length: buffer.readableBytes) failed")
+        guard let value = buffer.getString(at: buffer.readerIndex, length: buffer.readableBytes) else {
+            throw CodecError.invalidString
         }
-        return string
+        return value
     }
 }
 
-extension EventLoopLambdaHandler where Output == String {
+@available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
+extension LambdaHandler where Output == String {
     /// Implementation of `String` to `ByteBuffer` encoding.
     @inlinable
-    public func encode(allocator: ByteBufferAllocator, value: String) throws -> ByteBuffer? {
-        // FIXME: reusable buffer
-        var buffer = allocator.buffer(capacity: value.utf8.count)
+    public func encode(value: String, into buffer: inout ByteBuffer) throws {
+        buffer.writeString(value)
+    }
+}
+
+// MARK: - EventLoopLambdaHandler String support
+
+extension EventLoopLambdaHandler where Event == String {
+    /// Implementation of `String` to `ByteBuffer` encoding.
+    @inlinable
+    public func decode(buffer: ByteBuffer) throws -> String {
+        guard let value = buffer.getString(at: buffer.readerIndex, length: buffer.readableBytes) else {
+            throw CodecError.invalidString
+        }
+        return value
+    }
+}
+
+extension EventLoopLambdaHandler where Output == String {
+    /// Implementation of a `ByteBuffer` to `String` decoding.
+    @inlinable
+    public func encode(value: String, into buffer: inout ByteBuffer) throws {
         buffer.writeString(value)
-        return buffer
     }
 }

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -34,31 +34,24 @@ public enum Lambda {
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
 
-    internal static func run<Handler: ByteBufferLambdaHandler>(
+    @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
+    internal static func run<Handler: LambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, initializationHandler: Handler.makeHandler(context:))
+        Self.run(configuration: configuration, handlerType: CodableLambdaHandler<Handler, Handler.Event, Handler.Output>.self)
     }
 
     internal static func run<Handler: EventLoopLambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, initializationHandler: Handler.makeHandler(context:))
+        Self.run(configuration: configuration, handlerType: CodableEventLoopLambdaHandler<Handler, Handler.Event, Handler.Output>.self)
     }
 
-    @available(macOS 12, *)
-    internal static func run<Handler: LambdaHandler>(
+    internal static func run<Handler: ByteBufferLambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
-    ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, initializationHandler: Handler.makeHandler(context:))
-
-    }
-    private static func run(
-        configuration: LambdaConfiguration = .init(),
-        initializationHandler: @escaping _InitializationHandler
     ) -> Result<Int, Error> {
         let _run = { (configuration: LambdaConfiguration) -> Result<Int, Error> in
             Backtrace.install()
@@ -67,7 +60,7 @@ public enum Lambda {
 
             var result: Result<Int, Error>!
             MultiThreadedEventLoopGroup.withCurrentThreadAsEventLoop { eventLoop in
-                let runtime = LambdaRuntime(eventLoop: eventLoop, logger: logger, configuration: configuration, initializationHandler: initializationHandler)
+                let runtime = LambdaRuntime(handlerType, eventLoop: eventLoop, logger: logger, configuration: configuration)
                 #if DEBUG
                 let signalSource = trap(signal: configuration.lifecycle.stopSignal) { signal in
                     logger.info("intercepted signal: \(signal)")
@@ -89,7 +82,6 @@ public enum Lambda {
                     result = lifecycleResult
                 }
             }
-
             logger.info("shutdown completed")
             return result
         }