feat(request): Add a Request type (#2)

Author: pjechris

Sources/Pinata/DataCoder.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+/// A encoder suited to encode to Data
+public protocol DataEncoder {
+    func encode<T: Encodable>(_ value: T) throws -> Data
+}
+
+/// A decoder suited to decode Data
+public protocol DataDecoder {
+    func decode<T: Decodable>(_ type: T.Type, from: Data) throws -> T
+}
+
+/// A `DataEncoder` providing a `ContentType`
+public protocol ContentDataEncoder: DataEncoder {
+    /// a http content  type
+    static var contentType: HTTPContentType { get }
+}
+
+/// A `DataDecoder` providing a `ContentType`
+public protocol ContentDataDecoder: DataDecoder {
+    /// a http content  type
+    static var contentType: HTTPContentType { get }
+}

Sources/Pinata/Foundation/Encodable+Existential.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+extension Encodable {
+    /// Encode the object with provided encoder.
+    /// This technique allow to "open" an existential, that is to use it in a context where a generic is expected
+    func encoded(with encoder: DataEncoder) throws -> Data {
+        try encoder.encode(self)
+    }
+}

Sources/Pinata/Foundation/JSONEncoder+DataEncoder.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+extension JSONEncoder: ContentDataEncoder {
+    public static let contentType = HTTPContentType.json
+}

Sources/Pinata/Foundation/URL+Request.swift

@@ -0,0 +1,36 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+extension URL {
+    init<Output>(from request: Request<Output>) throws {
+        guard var components = URLComponents(string: request.path) else {
+            throw URLComponents.Error.invalid(path: request.path)
+        }
+        
+        let queryItems = (components.queryItems ?? []) + request.parameters.queryItems
+        
+        components.queryItems = queryItems.isEmpty ? nil : queryItems
+        
+        guard let url = components.url else {
+            throw URLComponents.Error.cannotGenerateURL(components: components)
+        }
+        
+        self = url
+    }
+}
+
+extension URLComponents {
+    enum Error: Swift.Error {
+        case invalid(path: String)
+        case cannotGenerateURL(components: URLComponents)
+    }
+}
+
+extension Dictionary where Key == String, Value == String {
+    fileprivate var queryItems: [URLQueryItem]  {
+        map { URLQueryItem(name: $0.key, value: $0.value) }
+    }
+}

Sources/Pinata/Foundation/URLRequest+Encode.swift

@@ -0,0 +1,22 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public extension URLRequest {
+    func encodedBody(_ body: Encodable, encoder: ContentDataEncoder) throws -> Self {
+        var request = self
+        
+        try request.encodeBody(body, encoder: encoder)
+        
+        return request
+    }
+    
+    /// Use a `Encodable` object as request body and set the "Content-Type" header associated to the encoder
+    mutating func encodeBody(_ body: Encodable, encoder: ContentDataEncoder) throws {
+        httpBody = try body.encoded(with: encoder)
+        setHeaders([.contentType: type(of: encoder).contentType.value])
+    }
+    
+}

Sources/Pinata/Foundation/URLRequest/URLRequest+Encode.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+extension URLRequest {
+    public mutating func setHeaders(_ headers: HTTPHeaderFields) {
+        for (header, value) in headers {
+            setValue(value, forHTTPHeaderField: header.key)
+        }
+    }
+}

Sources/Pinata/Foundation/URLRequest/URLRequest+HTTPHeader.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+/// A struct representing a http header content type value
+public struct HTTPContentType: Hashable, ExpressibleByStringLiteral {
+    let value: String
+    
+    public init(value: String) {
+        self.value = value
+    }
+    
+    public init(stringLiteral value: StringLiteralType) {
+        self.value = value
+    }
+}
+
+extension HTTPContentType {
+    public static let json: Self = "application/json"
+}

Sources/Pinata/HTTP/HTTPContentType.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+/// HTTP headers `Dictionary` and their associated value
+public typealias HTTPHeaderFields = [HTTPHeader: String]
+
+/// A struct representing a http request header key
+public struct HTTPHeader: Hashable, ExpressibleByStringLiteral {
+    public let key: String
+    
+    public init(stringLiteral value: StringLiteralType) {
+        self.key = value
+    }
+}
+
+extension HTTPHeader {
+    public static let accept: Self = "Accept"
+    public static let authentication: Self = "Authentication"
+    public static let contentType: Self = "Content-Type"
+}
+
+@available(*, unavailable, message: "This is a reserved header. See https://developer.apple.com/documentation/foundation/nsurlrequest#1776617")
+extension HTTPHeader {
+    public static let authorization: Self = "Authorization"
+    public static let connection: Self = "Connection"
+    public static let contentLength: Self = "Content-Length"
+    public static let host: Self = "Host"
+    public static let proxyAuthenticate: Self = "Proxy-Authenticate"
+    public static let proxyAuthorization: Self = "Proxy-Authorization"
+    public static let wwwAuthenticate: Self = "WWW-Authenticate"
+}

Sources/Pinata/HTTP/HTTPHeader.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+/// A Type representing a URL path
+public protocol Path {
+  var path: String { get }
+}
+
+extension Path where Self: RawRepresentable, RawValue == String {
+  public var path: String { rawValue }
+}
+
+extension String: Path {
+  public var path: String { self }
+}