Make ApiGw response composing more convenient

Author: stevapple

Sources/TencentSCFEvents/APIGateway.swift

@@ -13,6 +13,7 @@
 //===------------------------------------------------------------------------------------===//
 
 import struct Foundation.Data
+import class Foundation.JSONEncoder
 
 // https://cloud.tencent.com/document/product/583/12513
 
@@ -67,24 +68,58 @@ public enum APIGateway {
         public let body: String
         public let isBase64Encoded: Bool
 
+        public init<T: Encodable>(
+            statusCode: HTTPResponseStatus,
+            headers: HTTPHeaders = [:],
+            codableBody: T?
+        ) {
+            var headers = headers
+            headers["Content-Type"] = MIME.json.rawValue
+            self.headers = headers
+            do {
+                self.body = String(
+                    data: try JSONEncoder().encode(codableBody),
+                    encoding: .utf8
+                ) ?? ""
+                self.statusCode = statusCode
+            } catch let err {
+                self.body = #"{"errorType":"FunctionError","errorMsg":"\#(err.localizedDescription)"}"#
+                self.statusCode = .internalServerError
+            }
+            self.isBase64Encoded = false
+        }
+
         public init(
             statusCode: HTTPResponseStatus,
             headers: HTTPHeaders = [:],
-            body: String? = nil,
-            isBase64Encoded: Bool = false
+            type: MIME? = nil,
+            body: String? = nil
         ) {
             self.statusCode = statusCode
+            var headers = headers
+            if let type = type?.rawValue {
+                headers["Content-Type"] = type
+            } else {
+                headers["Content-Type"] = MIME.text.rawValue
+            }
             self.headers = headers
             self.body = body ?? ""
-            self.isBase64Encoded = isBase64Encoded
+            self.isBase64Encoded = false
         }
 
         public init(
             statusCode: HTTPResponseStatus,
             headers: HTTPHeaders = [:],
+            type: MIME? = nil,
             body: Data
         ) {
             self.statusCode = statusCode
+            var headers = headers
+            if let type = type?.rawValue {
+                headers["Content-Type"] = type
+            } else {
+                headers["Content-Type"] = MIME.octet.rawValue
+            }
             self.headers = headers
             self.body = body.base64EncodedString()
             self.isBase64Encoded = true

Sources/TencentSCFEvents/Utils/MIME.swift

@@ -0,0 +1,46 @@
+//===------------------------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftTencentSCFRuntime open source project
+//
+// Copyright (c) 2020 stevapple and the SwiftTencentSCFRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftTencentSCFRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===------------------------------------------------------------------------------------===//
+
+public struct MIME: RawRepresentable, CustomStringConvertible, Equatable, Hashable {
+    public typealias RawValue = String
+
+    public let rawValue: String
+
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+
+    public var description: String {
+        self.rawValue
+    }
+
+    public static var json: Self { MIME(rawValue: "application/json") }
+    public static var xml: Self { MIME(rawValue: "text/xml") }
+    public static var html: Self { MIME(rawValue: "text/html") }
+    public static var text: Self { MIME(rawValue: "text/plain") }
+    public static var octet: Self { MIME(rawValue: "application/octet-stream") }
+}
+
+extension MIME: Codable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let region = try container.decode(String.self)
+        self.init(rawValue: region)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.rawValue)
+    }
+}

Tests/TencentSCFEventsTests/APIGatewayTests.swift

@@ -81,7 +81,7 @@ class APIGatewayTests: XCTestCase {
                                       "accept": "text/html,application/xml,application/json",
                                       "host": "service-3ei3tii4-251000691.ap-guangzhou.apigateway.myqloud.com",
                                       "user-agent": "User Agent String",
-                                      "x-anonymous-consumer":  "true",
+                                      "x-anonymous-consumer": "true",
                                       "x-api-requestid": "24281851d905b02add27dad71656f29b",
                                       "x-b3-traceid": "24281851d905b02add27dad71656f29b",
                                       "x-qualifier": "$DEFAULT"])
@@ -104,7 +104,7 @@ class APIGatewayTests: XCTestCase {
     func testResponseEncodingWithText() {
         let resp = APIGateway.Response(
             statusCode: .ok,
-            headers: ["Content-Type": "text/plain"],
+            type: .text,
             body: "abc123"
         )
 
@@ -123,7 +123,6 @@ class APIGatewayTests: XCTestCase {
         let body = #"{"hello":"swift"}"#
         let resp = APIGateway.Response(
             statusCode: .ok,
-            headers: ["Content-Type": "application/json"],
             body: body.data(using: .utf8)!
         )
 
@@ -139,7 +138,66 @@ class APIGatewayTests: XCTestCase {
 
         XCTAssertEqual(newResp.statusCode, resp.statusCode)
         XCTAssertEqual(newResp.isBase64Encoded, true)
-        XCTAssertEqual(newResp.headers["Content-Type"], "application/json")
+        XCTAssertEqual(newResp.headers["Content-Type"], "application/octet-stream")
         XCTAssertEqual(Data(base64Encoded: newResp.body), body.data(using: .utf8))
     }
+
+    func testResponseEncodingWithCodable() {
+        struct Point: Codable, Equatable {
+            let x, y: Double
+        }
+        let point = Point(x: 1.0, y: -0.01)
+        let resp = APIGateway.Response(
+            statusCode: .ok,
+            codableBody: point
+        )
+
+        var data: Data?
+        XCTAssertNoThrow(data = try JSONEncoder().encode(resp))
+        var json: APIGateway.Response?
+        XCTAssertNoThrow(json = try JSONDecoder().decode(APIGateway.Response.self, from: XCTUnwrap(data)))
+
+        guard let newResp = json else {
+            XCTFail("Expected to have value")
+            return
+        }
+
+        XCTAssertEqual(newResp.statusCode, resp.statusCode)
+        XCTAssertEqual(newResp.isBase64Encoded, false)
+        XCTAssertEqual(newResp.headers["Content-Type"], "application/json")
+        XCTAssertEqual(try JSONDecoder().decode(Point.self, from: (newResp.body.data(using: .utf8))!), point)
+    }
+
+    func testResponseEncodingWithNil() {
+        let resp = APIGateway.Response(statusCode: .ok)
+
+        var data: Data?
+        XCTAssertNoThrow(data = try JSONEncoder().encode(resp))
+        var json: APIGateway.Response?
+        XCTAssertNoThrow(json = try JSONDecoder().decode(APIGateway.Response.self, from: XCTUnwrap(data)))
+
+        XCTAssertEqual(json?.statusCode, resp.statusCode)
+        XCTAssertEqual(json?.headers["Content-Type"], "text/plain")
+        XCTAssertEqual(json?.isBase64Encoded, false)
+        XCTAssertEqual(json?.body, "")
+    }
+
+    func testResponseEncodingWithCustomMIME() {
+        let mime = "application/x-javascript"
+        let resp = APIGateway.Response(
+            statusCode: .ok,
+            type: .init(rawValue: mime),
+            body: "console.log(\"Hello world!\");"
+        )
+
+        var data: Data?
+        XCTAssertNoThrow(data = try JSONEncoder().encode(resp))
+        var json: APIGateway.Response?
+        XCTAssertNoThrow(json = try JSONDecoder().decode(APIGateway.Response.self, from: XCTUnwrap(data)))
+
+        XCTAssertEqual(json?.statusCode, resp.statusCode)
+        XCTAssertEqual(json?.body, resp.body)
+        XCTAssertEqual(json?.isBase64Encoded, false)
+        XCTAssertEqual(json?.headers["Content-Type"], mime)
+    }
 }