feat(request): Add APIs to Request (#14)

Author: pjechris

README.md

@@ -67,7 +67,7 @@ struct UserBody: Encodable {}
 
 extension Request {
   static func login(_ body: UserBody) -> Self where Output == LoginResponse {
-    .post("login", body: .encodable(body))
+    .post("login", body: body)
   }
 }
 ```
@@ -86,13 +86,13 @@ extension Request {
   static func send(audio: URL) throws -> Self where Output == SendAudioResponse {
     var multipart = MultipartFormData()
     try multipart.add(url: audio, name: "define_your_name")
-    return .post("sendAudio", body: .multipart(multipart))
+    return .post("sendAudio", body: multipart)
   }
 
   static func send(audio: Data) throws -> Self where Output == SendAudioResponse {
     var multipart = MultipartFormData()
     try multipart.add(data: data, name: "your_name", fileName: "your_fileName", mimeType: "right_mimeType")
-    return .post("sendAudio", body: .multipart(multipart))
+    return .post("sendAudio", body: multipart)
   }
 }
 ```
@@ -107,7 +107,7 @@ extension Request {
     var multipart = MultipartFormData()
     try multipart.add(url: audio, name: "define_your_name")
     try multipart.add(data: image, name: "your_name", fileName: "your_fileName", mimeType: "right_mimeType")
-    return .post("sendAudioImage", body: .multipart(multipart))
+    return .post("sendAudioImage", body: multipart)
   }
 }
 ```

Sources/SimpleHTTP/Request/Endpoint.swift

@@ -21,9 +21,9 @@ import Foundation
 ///
 /// let user: Endpoint = .myEndpoints.user
 /// ```
-public struct Endpoint: Equatable, ExpressibleByStringLiteral {
+public struct Endpoint: Equatable, ExpressibleByStringLiteral, ExpressibleByStringInterpolation {
     /// relative path
-    let path: String
+    public let path: String
 
     init(path: String) {
         self.path = path
@@ -32,7 +32,11 @@ public struct Endpoint: Equatable, ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(path: value)
     }
-
+    
+    public init(stringInterpolation: DefaultStringInterpolation) {
+        self.init(path: stringInterpolation.description)
+    }
+    
     public static func ==(lhs: Endpoint, rhs: String) -> Bool {
         lhs.path == rhs
     }

Sources/SimpleHTTP/Request/Request+URLRequest.swift

@@ -24,6 +24,7 @@ extension Request {
         var urlRequest = try URLRequest(url: URL(from: self))
 
         urlRequest.httpMethod = method.rawValue.uppercased()
+        urlRequest.cachePolicy = cachePolicy
         urlRequest.setHeaders(headers)
 
         if let body = body {

Sources/SimpleHTTP/Request/Request.swift

@@ -4,6 +4,7 @@ public enum Method: String {
     case get
     case post
     case put
+    case patch
     case delete
 }
 
@@ -12,49 +13,92 @@ public enum Body {
     case multipart(MultipartFormData)
 }
 
-/// A Http request expecting an `Output` response
+/// A HTTP request safely typed for an `Output` response
 ///
 /// Highly inspired by https://swiftwithmajid.com/2021/02/10/building-type-safe-networking-in-swift/
 public struct Request<Output> {
-    
     /// request relative endpoint
     public let endpoint: Endpoint
     public let method: Method
     public let body: Body?
     public let query: [String: QueryParam]
+    public private(set) var cachePolicy: URLRequest.CachePolicy = .useProtocolCachePolicy
     public private(set) var headers: HTTPHeaderFields = [:]
 
+    /// Creates a request suitable for a HTTP GET
     public static func get(_ endpoint: Endpoint, query: [String: QueryParam] = [:]) -> Self {
         self.init(endpoint: endpoint, method: .get, query: query, body: nil)
     }
 
-    public static func post(_ endpoint: Endpoint, body: Body?, query: [String: QueryParam] = [:])
+    /// Creates a request suitable for a HTTP POST with a `Encodable` body
+    public static func post(_ endpoint: Endpoint, body: Encodable?, query: [String: QueryParam] = [:])
+    -> Self {
+        self.init(endpoint: endpoint, method: .post, query: query, body: body.map(Body.encodable))
+    }
+    
+    /// Creates a request suitable for a HTTP POST with a `MultipartFormData` body
+    @_disfavoredOverload
+    public static func post(_ endpoint: Endpoint, body: MultipartFormData?, query: [String: QueryParam] = [:])
+    -> Self {
+        self.init(endpoint: endpoint, method: .post, query: query, body: body.map(Body.multipart))
+    }
+    
+    /// Creates a request suitable for a HTTP PUT with a `Encodable` body
+    public static func put(_ endpoint: Endpoint, body: Encodable, query: [String: QueryParam] = [:])
+    -> Self {
+        self.init(endpoint: endpoint, method: .put, query: query, body: .encodable(body))
+    }
+    
+    /// Creates a request suitable for a HTTP PUT with a `MultipartFormData` body
+    public static func put(_ endpoint: Endpoint, body: MultipartFormData, query: [String: QueryParam] = [:])
     -> Self {
-        self.init(endpoint: endpoint, method: .post, query: query, body: body)
+        self.init(endpoint: endpoint, method: .put, query: query, body: .multipart(body))
     }
 
-    public static func put(_ endpoint: Endpoint, body: Body, query: [String: QueryParam] = [:])
+    /// Creates a request suitable for a HTTP PATCH with a `Encodable` body
+    public static func patch(_ endpoint: Endpoint, body: Encodable, query: [String: QueryParam] = [:])
     -> Self {
-        self.init(endpoint: endpoint, method: .put, query: query, body: body)
+        self.init(endpoint: endpoint, method: .patch, query: query, body: .encodable(body))
     }
 
+    /// Creates a request suitable for a HTTP PATCH with a `MultipartFormData` body
+    public static func patch(_ endpoint: Endpoint, body: MultipartFormData, query: [String: QueryParam] = [:])
+    -> Self {
+        self.init(endpoint: endpoint, method: .patch, query: query, body: .multipart(body))
+    }
+    
+    /// Creates a request suitable for a HTTP DELETE
+    /// Default implementation does not allow for sending a body. If you need such a case extend Request with your
+    /// own init method
     public static func delete(_ endpoint: Endpoint, query: [String: QueryParam] = [:]) -> Self {
         self.init(endpoint: endpoint, method: .delete, query: query, body: nil)
     }
 
-    private init(endpoint: Endpoint, method: Method, query: [String: QueryParam], body: Body?) {
+    /// Creates a Request.
+    ///
+    /// Use this init only if default provided static initializers (`.get`, `.post`, `.put`, `patch`, `.delete`) do not suit your needs.
+    public init(endpoint: Endpoint, method: Method, query: [String: QueryParam], body: Body?) {
         self.endpoint = endpoint
         self.method = method
         self.body = body
         self.query = query
     }
 
-    /// add headers to the request
+    /// Adds headers to the request
     public func headers(_ newHeaders: [HTTPHeader: String]) -> Self {
         var request = self
 
         request.headers.merge(newHeaders) { $1 }
 
         return request
     }
+    
+    /// Configures request cache policy
+    public func cachePolicy(_ policy: URLRequest.CachePolicy) -> Self {
+        var request = self
+        
+        request.cachePolicy = policy
+        
+        return request
+    }
 }

Tests/SimpleHTTPTests/Request/RequestTests.swift

@@ -18,62 +18,71 @@ class RequestTests: XCTestCase {
 
         XCTAssertEqual(request.httpMethod, "POST")
     }
-
-    func test_toURLRequest_EncodeBody() throws {
-      let request = try Request<Void>.post(.test, body: .encodable(Body()))
+    
+    func test_toURLRequest_encodeBody() throws {
+        let request = try Request<Void>.post(.test, body: BodyMock())
             .toURLRequest(encoder: JSONEncoder(), relativeTo: baseURL)
-
-      XCTAssertEqual(request.httpBody, try JSONEncoder().encode(Body()))
+        
+        XCTAssertEqual(request.httpBody, try JSONEncoder().encode(BodyMock()))
     }
-
+    
+    func test_toURLRequest_setCachePolicy() throws {
+        let request = try Request<Void>
+            .get(.test)
+            .cachePolicy(.returnCacheDataDontLoad)
+            .toURLRequest(encoder: JSONEncoder(), relativeTo: baseURL)
+        
+        XCTAssertEqual(request.cachePolicy, .returnCacheDataDontLoad)
+    }
+    
     func test_toURLRequest_encodeMultipartBody() throws {
-      let crlf = EncodingCharacters.crlf
-      let boundary = "boundary"
-      var multipart = MultipartFormData(boundary: boundary)
-      let url = try url(forResource: "swift", withExtension: "png")
-      let name = "swift"
-      try multipart.add(url: url, name: name)
-
-      let request = try Request<Void>.post(.test, body: .multipart(multipart))
+        let crlf = EncodingCharacters.crlf
+        let boundary = "boundary"
+        var multipart = MultipartFormData(boundary: boundary)
+        let url = try url(forResource: "swift", withExtension: "png")
+        let name = "swift"
+        try multipart.add(url: url, name: name)
+        
+        let request = try Request<Void>.post(.test, body: multipart)
             .toURLRequest(encoder: JSONEncoder(), relativeTo: baseURL)
-
-      /// We can't use  `XCTAssertEqual(request.httpBody, try multipart.encode)`
-      /// The `encode` method is executed to fast and rase and error
-      var body = Data()
-      body.append(Boundary.data(for: .initial, boundary: boundary))
-      body.append(
-        Data((
-          "Content-Disposition: form-data; name=\"\(name)\"; filename=\"swift.png\"\(crlf)"
-            + "Content-Type: image/png\(crlf)\(crlf)"
-        ).utf8)
-      )
-      body.append(try Data(contentsOf: url))
-      body.append(Boundary.data(for: .final, boundary: boundary))
-      XCTAssertEqual(request.httpBody, body)
+        
+        /// We can't use  `XCTAssertEqual(request.httpBody, try multipart.encode)`
+        /// The `encode` method is executed to fast and rase and error
+        var body = Data()
+        body.append(Boundary.data(for: .initial, boundary: boundary))
+        body.append(
+            Data((
+                "Content-Disposition: form-data; name=\"\(name)\"; filename=\"swift.png\"\(crlf)"
+                + "Content-Type: image/png\(crlf)\(crlf)"
+            ).utf8)
+        )
+        body.append(try Data(contentsOf: url))
+        body.append(Boundary.data(for: .final, boundary: boundary))
+        XCTAssertEqual(request.httpBody, body)
     }
-
-    func test_toURLRequest_bodyIsEncodable_FillDefaultHeaders() throws {
-      let request = try Request<Void>.post(.test, body: .encodable(Body()))
+    
+    func test_toURLRequest_bodyIsEncodable_fillContentTypeHeader() throws {
+        let request = try Request<Void>.post(.test, body: BodyMock())
             .toURLRequest(encoder: JSONEncoder(), relativeTo: baseURL)
-
-      XCTAssertEqual(request.allHTTPHeaderFields?["Content-Type"], "application/json")
+        
+        XCTAssertEqual(request.allHTTPHeaderFields?["Content-Type"], "application/json")
     }
-
-    func test_toURLRequest_bodyIsMultipart_itFillDefaultHeaders() throws {
-      let boundary = "boundary"
-      var multipart = MultipartFormData(boundary: boundary)
-      let url = try url(forResource: "swift", withExtension: "png")
-      let name = "swift"
-      try multipart.add(url: url, name: name)
-
-      let request = try Request<Void>.post(.test, body: .multipart(multipart))
+    
+    func test_toURLRequest_bodyIsMultipart_fillContentTypeHeader() throws {
+        let boundary = "boundary"
+        var multipart = MultipartFormData(boundary: boundary)
+        let url = try url(forResource: "swift", withExtension: "png")
+        let name = "swift"
+        try multipart.add(url: url, name: name)
+        
+        let request = try Request<Void>.post(.test, body: multipart)
             .toURLRequest(encoder: JSONEncoder(), relativeTo: baseURL)
-
-      XCTAssertEqual(request.allHTTPHeaderFields?["Content-Type"], HTTPContentType.multipart(boundary: multipart.boundary).value)
+        
+        XCTAssertEqual(request.allHTTPHeaderFields?["Content-Type"], HTTPContentType.multipart(boundary: multipart.boundary).value)
     }
 
 }
 
-private struct Body: Encodable {
+private struct BodyMock: Encodable {
 
 }