140 lines
4.0 KiB
Swift
140 lines
4.0 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 struct Hermes {
|
|
|
|
public init() { }
|
|
|
|
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
|
|
}
|
|
|
|
headers["Authorization"] = "Bearer \(token)"
|
|
|
|
return headers
|
|
}
|
|
|
|
public func load<T: Codable>(_ resource: Resource<T>) async throws -> T {
|
|
|
|
var request = URLRequest(url: resource.url)
|
|
|
|
switch resource.method {
|
|
case .get(let queryItems):
|
|
var components = URLComponents(url: resource.url, resolvingAgainstBaseURL: false)
|
|
components?.queryItems = queryItems
|
|
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:
|
|
request.httpMethod = resource.method.name
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|