📝Edit SPM repo url in README

.gitea/workflows/hermes.yml

@@ -1,20 +0,0 @@
-name: Run Swift Tests
-
-on:
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: macos
-
-    steps:
-    - name: ⬇️ Checkout code v3
-      uses: actions/checkout@v4
-
-    - name: 🛠️ Setup node
-      uses: actions/setup-node@v4
-
-    - name: 🧪 Test
-      run: swift test

.gitignore

@@ -1,6 +1,5 @@
 .DS_Store
 /.build
-/.vscode
 /Packages
 xcuserdata/
 DerivedData/

Sources/Hermes/Hermes.swift

@@ -11,7 +11,6 @@ public enum NetworkError: Error {
     case serverError(String)
     case decodingError
     case invalidResponse
-    case notFound
 }
 
 extension NetworkError: LocalizedError {
@@ -20,19 +19,18 @@ extension NetworkError: LocalizedError {
             case .badRequest:
                 return NSLocalizedString("Unable to perform request", comment: "badRequestError")
             case .serverError(let errorMessage):
+                print(errorMessage)
                 return NSLocalizedString(errorMessage, comment: "serverError")
             case .decodingError:
                 return NSLocalizedString("Unable to decode successfully", comment: "decodingError")
             case .invalidResponse:
                 return NSLocalizedString("Invalid response", comment: "invalidResponse")
-            case .notFound:
-                return NSLocalizedString("Not Found", comment: "notFound")
         }
     }
 }
 
 public enum HTTPMethod {
-    case get([URLQueryItem]? = nil)
+    case get([URLQueryItem])
     case post(Data?)
     case put(Data?)
     case patch(Data?)
@@ -66,48 +64,45 @@ public struct Resource<T: Codable> {
     }
 }
 
-public final class Hermes {
+public struct Hermes {
-    public static let shared = Hermes()
-    private var config: HermesConfiguration
     
-    private init(config: HermesConfiguration = HermesConfiguration()) {
+    public init() { }
-        self.config = config
-    }
-    
-    public func configure(_ config: HermesConfiguration) {
-        self.config = config
-    }
     
     private var defaultHeaders: [String: String] {
         var headers = ["Content-Type": "application/json"]
-        if let token = UserDefaults.standard.string(forKey: "authToken") {
+        let defaults = UserDefaults.standard
-            headers["Authorization"] = "Bearer \(token)"
+        guard let token = defaults.string(forKey: "authToken") else {
+            return headers
         }
-        headers.merge(config.defaultHeaders) { (_, new) in new }
+        
+        headers["Authorization"] = "Bearer \(token)"
+        
         return headers
     }
     
     public func load<T: Codable>(_ resource: Resource<T>) async throws -> T {
         
         var request = URLRequest(url: resource.url)
-        request.httpMethod = resource.method.name
         
         switch resource.method {
             case .get(let queryItems):
-            if let queryItems = queryItems {
                 var components = URLComponents(url: resource.url, resolvingAgainstBaseURL: false)
                 components?.queryItems = queryItems
-                request.url = components?.url
+            guard let url = components?.url else {
+                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:
-            break
-        }
             
-        request.allHTTPHeaderFields = defaultHeaders
+        case .delete:
+            request.httpMethod = resource.method.name
+        }
         
         let configuration = URLSessionConfiguration.default
         configuration.httpAdditionalHeaders = defaultHeaders
@@ -115,34 +110,14 @@ public final class Hermes {
         
         let (data, response) = try await session.data(for: request)
         
-        guard let httpResponse = response as? HTTPURLResponse else {
+        guard let _ = response as? HTTPURLResponse else {
             throw NetworkError.invalidResponse
         }
         
-        try validate(response: httpResponse)
+        guard let result = try? JSONDecoder().decode(resource.modelType, from: data) else {
-        
-        let decoder = JSONDecoder()
-        decoder.keyDecodingStrategy = config.decodingStrategy
-        
-        do {
-            return try decoder.decode(resource.modelType, from: data)
-        } catch {
             throw NetworkError.decodingError
         }
-    }
         
-    private func validate(response: HTTPURLResponse) throws {
+        return result
-        switch response.statusCode {
-            case 200...299:
-                return
-            case 400:
-                throw NetworkError.badRequest
-            case 404:
-                throw NetworkError.notFound
-            case 500:
-                throw NetworkError.serverError("Internal Server Error")
-            default:
-                throw NetworkError.invalidResponse
-        }
     }
 }

Sources/Hermes/HermesConfiguration.swift

@@ -1,18 +0,0 @@
-//
-//  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,139 +1,12 @@
-@testable import Hermes
 import XCTest
+@testable import Hermes
 
 final class HermesTests: XCTestCase {
-    override func setUp() {
+    func testExample() throws {
-        super.setUp()
+        // XCTest Documentation
-        configureHermes()
+        // https://developer.apple.com/documentation/xctest
-    }
 
-    private func configureHermes() {
+        // Defining Test Cases and Test Methods
-        let defaultHeaders = ["Custom-Header": "HeaderValue"]
+        // https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
-        let decodingStrategy = JSONDecoder.KeyDecodingStrategy.convertFromSnakeCase
-        let config = HermesConfiguration(defaultHeaders: defaultHeaders, decodingStrategy: decodingStrategy)
-        Hermes.shared.configure(config)
-    }
-    
-    func testGetRequest() async throws {
-        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.shared.load(resource)
-        
-        XCTAssertEqual(getResponse.url, "https://httpbin.org/get?foo=bar")
-        XCTAssertEqual(getResponse.args.count, 1)
-        XCTAssertGreaterThan(getResponse.headers.count, 0)
-    }
-    
-    func testPostRequest() async throws {
-        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.shared.load(resource)
-        
-        XCTAssertEqual(postResponse.url, "https://httpbin.org/post")
-        XCTAssertEqual(postResponse.args.count, 0)
-        XCTAssertNotNil(postResponse.json)
-        XCTAssertEqual(postResponse.json?.count, 1)
-        XCTAssertGreaterThan(postResponse.headers.count, 0)
-    }
-    
-    func testPutRequest() async throws {
-        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.shared.load(resource)
-        
-        XCTAssertEqual(putResponse.url, "https://httpbin.org/put")
-        XCTAssertEqual(putResponse.args.count, 0)
-        XCTAssertNotNil(putResponse.json)
-        XCTAssertEqual(putResponse.json?.count, 1)
-        XCTAssertGreaterThan(putResponse.headers.count, 0)
-    }
-    
-    func testPatchRequest() async throws {
-        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.shared.load(resource)
-        
-        XCTAssertEqual(patchResponse.url, "https://httpbin.org/patch")
-        XCTAssertEqual(patchResponse.args.count, 0)
-        XCTAssertNotNil(patchResponse.json)
-        XCTAssertEqual(patchResponse.json?.count, 1)
-        XCTAssertGreaterThan(patchResponse.headers.count, 0)
-    }
-    
-    func testDeleteRequest() async throws {
-        let resource = Resource(url: URL(string: "https://httpbin.org/delete")!, method: .delete, modelType: PostResponse.self)
-        
-        let deleteResponse = try await Hermes.shared.load(resource)
-        
-        XCTAssertEqual(deleteResponse.url, "https://httpbin.org/delete")
-        XCTAssertEqual(deleteResponse.args.count, 0)
-        XCTAssertNil(deleteResponse.json)
-        XCTAssertGreaterThan(deleteResponse.headers.count, 0)
-    }
-    
-    func testNotFound() async throws {
-        let resource = Resource(url: URL(string: "https://httpbin.org/status/404")!, method: .get(), modelType: GetResponse.self)
-        
-        do {
-            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 resource = Resource(url: URL(string: "https://httpbin.org/status/500")!, method: .get(), modelType: GetResponse.self)
-        
-        do {
-            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 resource = Resource(url: URL(string: "https://httpbin.org/get")!, method: .get(), modelType: DummyResponse.self)
-        
-        do {
-            let _ = try await Hermes.shared.load(resource)
-            XCTFail("Expected to throw NetworkError.decodingError")
-        } catch NetworkError.decodingError {
-            XCTAssert(true)
-        } catch {
-            XCTFail("Unexpected error: \(error)")
-        }
-    }
-}
-
-struct GetResponse: Codable {
-    let args: [String: String]
-    let headers: [String: String]
-    let origin: String
-    let url: String
-}
-
-struct PostResponse: Codable {
-    let args: [String: String]
-    let data: String
-    let files: [String: String]
-    let form: [String: String]
-    let headers: [String: String]
-    let json: [String: String]?
-    let origin: String
-    let url: String
-}
-
-struct DummyResponse: Codable {
-    let dumb: Int
-    let dumber: Double
-}