How can I create a generic API loader in Swift for multiple endpoints?

You can solve this by making your API loader function generic. This way, you pass the type that conforms to Codable (or Decodable) as a parameter to your function, and then use that type when decoding. Here's an example of how you might refactor your function:

---

SWIFTCopied
func apiLoader<T: Codable>(urlString: String,
                           type: T.Type,
                           completion: @escaping (Result<T, Error>) -> Void) {
    
    // Create API URL
    guard let url = URL(string: urlString) else {
        fatalError("Invalid URL string")
    }
    
    // Create URL Request
    var request = URLRequest(url: url)
    
    // Specify Headers to use
    let headers = [
        "x-rapidapi-key": "REDACTED",
        "x-rapidapi-host": "REDACTED.p.rapidapi.com"
    ]
    request.httpMethod = "GET"
    request.allHTTPHeaderFields = headers
    
    // Send HTTP Request
    URLSession.shared.dataTask(with: request) { data, response, error in
        // Check if Error took place
        if let error = error {
            completion(.failure(error))
            return
        }
        
        // Ensure we got some data
        guard let data = data else {
            completion(.failure(URLError(.badServerResponse)))
            return
        }
        
        do {
            // Prepare decoder with custom settings.
            let dateFormatter = DateFormatter()
            dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'"
            
            let decoder = JSONDecoder()
            decoder.keyDecodingStrategy = .convertFromSnakeCase
            decoder.dateDecodingStrategy = .formatted(dateFormatter)
            
            // Decode the data to the provided type
            let decodedObject = try decoder.decode(type, from: data)
            completion(.success(decodedObject))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

---

How to Use This Function

Assuming you have your data model declared as before:

SWIFTCopied
@Observable class HockeyTimeZones: ObservableObject, Codable {
    var get: String? = nil
    var parameters: [String]? = []
    var errors: [String]? = []
    var results: Int? = nil
    var response: [String]? = []
    
    enum CodingKeys: String, CodingKey {
        case _get        = "get"
        case _parameters = "parameters"
        case _errors     = "errors"
        case _results    = "results"
        case _response   = "response"
    }
    
    required init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        get = try values.decodeIfPresent(String.self, forKey: ._get)
        parameters = try values.decodeIfPresent([String].self, forKey: ._parameters)
        errors = try values.decodeIfPresent([String].self, forKey: ._errors)
        results = try values.decodeIfPresent(Int.self, forKey: ._results)
        response = try values.decodeIfPresent([String].self, forKey: ._response)
    }
    
    init() { }
}

You can call your API loader for HockeyTimeZones like this:

SWIFTCopied
apiLoader(urlString: "https://api-hockey.p.rapidapi.com/timezone",
          type: HockeyTimeZones.self) { result in
    switch result {
    case .success(let hockeyTimeZones):
        hockeyTimeZones.response?.forEach { timezone in
            print(timezone)
        }
    case .failure(let error):
        print("Failed to load data: \(error)")
    }
}

Explanation

• Generic Parameter (T):
  The function is generic over T where T conforms to Codable. This allows you to pass any Codable type (like HockeyTimeZones or any of your other 6 data models) to the function.

• Type Parameter:
  The parameter type: T.Type is used to specify the specific model type to decode. For example, HockeyTimeZones.self is passed when you want to decode the response into a HockeyTimeZones object.

• Completion Handler:
  We use a result-based completion handler so that you can handle success (with the decoded object) or failure (with an error).

This approach keeps your API loader flexible and reusable for all endpoints without having to duplicate code for each model type.