149 lines
4.3 KiB
Swift
149 lines
4.3 KiB
Swift
//
|
|
// hermes.swift
|
|
//
|
|
// Created by victor bodinaud on 11/01/2024.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
public enum NetworkError: Error {
|
|
case badRequest
|
|
case serverError(String)
|
|
case decodingError
|
|
case invalidResponse
|
|
case notFound
|
|
}
|
|
|
|
extension NetworkError: LocalizedError {
|
|
public var errorDescription: String? {
|
|
switch self {
|
|
case .badRequest:
|
|
return NSLocalizedString("Unable to perform request", comment: "badRequestError")
|
|
case .serverError(let 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 post(Data?)
|
|
case put(Data?)
|
|
case patch(Data?)
|
|
case delete
|
|
|
|
var name: String {
|
|
switch self {
|
|
case .get:
|
|
return "GET"
|
|
case .post:
|
|
return "POST"
|
|
case .put:
|
|
return "PUT"
|
|
case .patch:
|
|
return "PATCH"
|
|
case .delete:
|
|
return "DELETE"
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct Resource<T: Codable> {
|
|
let url: URL
|
|
var method: HTTPMethod = .get([])
|
|
var modelType: T.Type
|
|
|
|
public init(url: URL, method: HTTPMethod, modelType: T.Type) {
|
|
self.url = url
|
|
self.method = method
|
|
self.modelType = modelType
|
|
}
|
|
}
|
|
|
|
public final class Hermes {
|
|
public static let shared = Hermes()
|
|
private var config: HermesConfiguration
|
|
|
|
private init(config: HermesConfiguration = HermesConfiguration()) {
|
|
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") {
|
|
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
|
|
|
|
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
|
|
}
|
|
case .post(let data),
|
|
.put(let data),
|
|
.patch(let data):
|
|
request.httpBody = data
|
|
case .delete:
|
|
break
|
|
}
|
|
|
|
request.allHTTPHeaderFields = defaultHeaders
|
|
|
|
let configuration = URLSessionConfiguration.default
|
|
configuration.httpAdditionalHeaders = defaultHeaders
|
|
let session = URLSession(configuration: configuration)
|
|
|
|
let (data, response) = try await session.data(for: request)
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
private func validate(response: HTTPURLResponse) throws {
|
|
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
|
|
}
|
|
}
|
|
}
|