✨ Remove unused default headers & allow request specific headers

Add global configuration, refactoring & updated testing

Sources/Hermes/Hermes.swift

@@ -14,6 +14,11 @@ public enum NetworkError: Error {
     case notFound
 }
 
+public protocol HermesMiddleware {
+    func processRequest(_ request: inout URLRequest)
+    func processResponse(_ data: Data?, _ response: URLResponse?, error: Error?)
+}
+
 extension NetworkError: LocalizedError {
     public var errorDescription: String? {
         switch self {
@@ -58,82 +63,118 @@ public struct Resource<T: Codable> {
     let url: URL
     var method: HTTPMethod = .get([])
     var modelType: T.Type
+    var headers: [String: String]
     
-    public init(url: URL, method: HTTPMethod, modelType: T.Type) {
+    public init(url: URL, method: HTTPMethod, modelType: T.Type, headers: [String: String] = [:]) {
         self.url = url
         self.method = method
         self.modelType = modelType
+        self.headers = headers
     }
 }
 
-public struct Hermes {
+public final class Hermes {
+    public static let shared = Hermes()
+    private var config: HermesConfiguration
+    private var middlewares: [HermesMiddleware] = []
 
-    public init() { }
+    private init(config: HermesConfiguration = HermesConfiguration()) {
+        self.config = config
+    }
+    
+    public func configure(_ config: HermesConfiguration) {
+        self.config = config
+    }
+
+    public func addMiddleware(_ middleware: HermesMiddleware) {
+        middlewares.append(middleware)
+    }
 
     private var defaultHeaders: [String: String] {
-        var headers = ["Content-Type": "application/json"]
-        let defaults = UserDefaults.standard
-        guard let token = defaults.string(forKey: "authToken") else {
-            return headers
-        }
+        var headers = [
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        ]
         
-        headers["Authorization"] = "Bearer \(token)"
+        headers.merge(config.defaultHeaders) { _, new in new }
         
         return headers
     }
     
     public func load<T: Codable>(_ resource: Resource<T>) async throws -> T {
-        
         var request = URLRequest(url: resource.url)
+        request.httpMethod = resource.method.name
+
+        for middleware in middlewares {
+            middleware.processRequest(&request)
+        }
 
         switch resource.method {
             case .get(let queryItems):
-                var components = URLComponents(url: resource.url, resolvingAgainstBaseURL: false)
-                components?.queryItems = queryItems
-            guard let url = components?.url else {
+                if let queryItems = queryItems {
+                    var components = URLComponents(url: resource.url, resolvingAgainstBaseURL: false)
+                    components?.queryItems = queryItems
+                    request.url = components?.url
+                }
+            case .post(let data),
+                 .put(let data),
+                 .patch(let data):
+                request.httpBody = data
+            case .delete:
+                break
+        }
+        
+        var headers = defaultHeaders
+        
+        if !resource.headers.isEmpty {
+            headers.merge(resource.headers) { _, new in new }
+        }
+        
+        request.allHTTPHeaderFields = headers
+        
+        let session = URLSession(configuration: URLSessionConfiguration.default)
+        
+        do {
+            let (data, response) = try await session.data(for: request)
+
+            for middleware in middlewares {
+                middleware.processResponse(data, response, error: nil)
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                throw NetworkError.invalidResponse
+            }
+
+            try validate(response: httpResponse)
+
+            let decoder = JSONDecoder()
+            decoder.keyDecodingStrategy = config.decodingStrategy
+
+            do {
+                return try decoder.decode(resource.modelType, from: data)
+            } catch {
+                throw NetworkError.decodingError
+            }
+        } catch {
+            for middleware in middlewares {
+                middleware.processResponse(nil, nil, error: error)
+            }
+            throw error
+        }
+    }
+    
+    private func validate(response: HTTPURLResponse) throws {
+        switch response.statusCode {
+            case 200 ... 299:
+                return
+            case 400:
                 throw NetworkError.badRequest
-            }
-            
-            request = URLRequest(url: url)
-            
-        case .post(let data),
-             .put(let data),
-             .patch(let data):
-            request.httpMethod = resource.method.name
-            request.httpBody = data
-            
-        case .delete:
-            request.httpMethod = resource.method.name
+            case 404:
+                throw NetworkError.notFound
+            case 500:
+                throw NetworkError.serverError("Internal Server Error")
+            default:
+                throw NetworkError.invalidResponse
         }
-        
-        let configuration = URLSessionConfiguration.default
-        configuration.httpAdditionalHeaders = defaultHeaders
-        let session = URLSession(configuration: configuration)
-        
-        let (data, response) = try await session.data(for: request)
-        
-        guard let response = response as? HTTPURLResponse else {
-            throw NetworkError.invalidResponse
-        }
-        
-        if response.statusCode != 200 {
-            switch response.statusCode {
-                case 404:
-                    throw NetworkError.notFound
-                case 500:
-                    throw NetworkError.serverError(response.description)
-                default:
-                    throw NetworkError.invalidResponse
-            }
-        }
-        
-        let decoder = JSONDecoder()
-        decoder.keyDecodingStrategy = .convertFromSnakeCase
-        
-        guard let result = try? decoder.decode(resource.modelType, from: data) else {
-            throw NetworkError.decodingError
-        }
-        
-        return result
     }
 }

Sources/Hermes/HermesConfiguration.swift

@@ -0,0 +1,18 @@
+//
+//  HermesConfiguration.swift
+//
+//
+//  Created by Victor on 28/05/2024.
+//
+
+import Foundation
+
+public struct HermesConfiguration {
+    var defaultHeaders: [String: String] = [:]
+    var decodingStrategy: JSONDecoder.KeyDecodingStrategy = .useDefaultKeys
+    
+    public init(defaultHeaders: [String: String] = [:], decodingStrategy: JSONDecoder.KeyDecodingStrategy = .useDefaultKeys) {
+        self.defaultHeaders = defaultHeaders
+        self.decodingStrategy = decodingStrategy
+    }
+}

Tests/HermesTests/HermesTests.swift

@@ -1,14 +1,24 @@
-import XCTest
 @testable import Hermes
+import XCTest
 
 final class HermesTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        configureHermes()
+    }
+    
+    private func configureHermes() {
+        let defaultHeaders = ["Custom-Header": "HeaderValue"]
+        let decodingStrategy = JSONDecoder.KeyDecodingStrategy.convertFromSnakeCase
+        let config = HermesConfiguration(defaultHeaders: defaultHeaders, decodingStrategy: decodingStrategy)
+        Hermes.shared.configure(config)
+    }
     
     func testGetRequest() async throws {
-        let hermes = Hermes()
         let queryParams = [URLQueryItem(name: "foo", value: "bar")]
         let resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(queryParams), modelType: GetResponse.self)
         
-        let getResponse = try await hermes.load(resource)
+        let getResponse = try await Hermes.shared.load(resource)
         
         XCTAssertEqual(getResponse.url, "https://httpbin.org/get?foo=bar")
         XCTAssertEqual(getResponse.args.count, 1)
@@ -16,52 +26,48 @@ final class HermesTests: XCTestCase {
     }
     
     func testPostRequest() async throws {
-        let hermes = Hermes()
         let postDatas = try? JSONEncoder().encode(["foo": "bar"])
         let resource = Resource(url: URL(string: "https://httpbin.org/post")!, method: .post(postDatas), modelType: PostResponse.self)
         
-        let postResponse = try await hermes.load(resource)
+        let postResponse = try await Hermes.shared.load(resource)
         
         XCTAssertEqual(postResponse.url, "https://httpbin.org/post")
         XCTAssertEqual(postResponse.args.count, 0)
         XCTAssertNotNil(postResponse.json)
-        XCTAssertEqual(postResponse.json!.count, 1)
+        XCTAssertEqual(postResponse.json?.count, 1)
         XCTAssertGreaterThan(postResponse.headers.count, 0)
     }
     
     func testPutRequest() async throws {
-        let hermes = Hermes()
         let postDatas = try? JSONEncoder().encode(["foo": "bar"])
         let resource = Resource(url: URL(string: "https://httpbin.org/put")!, method: .put(postDatas), modelType: PostResponse.self)
         
-        let putResponse = try await hermes.load(resource)
+        let putResponse = try await Hermes.shared.load(resource)
         
         XCTAssertEqual(putResponse.url, "https://httpbin.org/put")
         XCTAssertEqual(putResponse.args.count, 0)
         XCTAssertNotNil(putResponse.json)
-        XCTAssertEqual(putResponse.json!.count, 1)
+        XCTAssertEqual(putResponse.json?.count, 1)
         XCTAssertGreaterThan(putResponse.headers.count, 0)
     }
     
     func testPatchRequest() async throws {
-        let hermes = Hermes()
         let postDatas = try? JSONEncoder().encode(["foo": "bar"])
         let resource = Resource(url: URL(string: "https://httpbin.org/patch")!, method: .patch(postDatas), modelType: PostResponse.self)
         
-        let patchResponse = try await hermes.load(resource)
+        let patchResponse = try await Hermes.shared.load(resource)
         
         XCTAssertEqual(patchResponse.url, "https://httpbin.org/patch")
         XCTAssertEqual(patchResponse.args.count, 0)
         XCTAssertNotNil(patchResponse.json)
-        XCTAssertEqual(patchResponse.json!.count, 1)
+        XCTAssertEqual(patchResponse.json?.count, 1)
         XCTAssertGreaterThan(patchResponse.headers.count, 0)
     }
     
     func testDeleteRequest() async throws {
-        let hermes = Hermes()
         let resource = Resource(url: URL(string: "https://httpbin.org/delete")!, method: .delete, modelType: PostResponse.self)
         
-        let deleteResponse = try await hermes.load(resource)
+        let deleteResponse = try await Hermes.shared.load(resource)
         
         XCTAssertEqual(deleteResponse.url, "https://httpbin.org/delete")
         XCTAssertEqual(deleteResponse.args.count, 0)
@@ -70,35 +76,41 @@ final class HermesTests: XCTestCase {
     }
     
     func testNotFound() async throws {
-        let hermes = Hermes()
         let resource = Resource(url: URL(string: "https://httpbin.org/status/404")!, method: .get(), modelType: GetResponse.self)
         
         do {
-            let _ = try await hermes.load(resource)
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.notFound")
         } catch NetworkError.notFound {
             XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
         }
     }
     
     func testServerError() async throws {
-        let hermes = Hermes()
         let resource = Resource(url: URL(string: "https://httpbin.org/status/500")!, method: .get(), modelType: GetResponse.self)
         
         do {
-            let _ = try await hermes.load(resource)
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.serverError")
         } catch NetworkError.serverError(_) {
             XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
         }
     }
     
     func testDecodeError() async throws {
-        let hermes = Hermes()
         let resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(), modelType: DummyResponse.self)
         
         do {
-            let _ = try await hermes.load(resource)
+            let _ = try await Hermes.shared.load(resource)
+            XCTFail("Expected to throw NetworkError.decodingError")
         } catch NetworkError.decodingError {
             XCTAssert(true)
+        } catch {
+            XCTFail("Unexpected error: \(error)")
         }
     }
 }