Struggling with creating a generic api client

[inwoodev]

Hello, I am trying to build a testable generic api client that returns decodable type.

here is the api endpoint type that I am thinking of using:

import Foundation

enum APIEndpoint {
  enum HTTPMethod: String {
    case get = "GET"
    case post = "POST"
    case delete = "DELETE"
    case put = "PUT"
  }
  
  case getVerificationCode
// more cases would be included
  
  var baseURL: String {
    return "https://baseURL"
  }
  
  var path: String {
    switch self {
    case .getVerificationCode:
      return "/getVerificationCode"
    }
  }
  
  var parameters: [String: Any]? {
    switch self {
    default:
      return nil
    }
  }
  
  var method: HTTPMethod {
    switch self {
    case .getVerificationCode:
      return .post
    }
  }
  
  var urlString: String {
    guard var urlComponents = URLComponents(string: baseURL) else {
      return baseURL
    }
    
    urlComponents.path = path
    
    if let parameters = parameters {
      let queryItems = parameters.map { key, value in
        URLQueryItem(name: key, value: "\(value)")
      }
      urlComponents.queryItems = queryItems
    }
    return urlComponents.url?.absoluteString ?? baseURL
  }
}

I have checked other Q&A's and figured out that generic types could be used with helper methods, so I tried to set up in a similar way, but I am stuck here:

import ComposableArchitecture
import Foundation

enum APIError: Error {
  case encodingDecodingError
}

struct APIClient {
  var _request: (APIEndpoint) async throws -> Data
  
  func request<T: Decodable>(endpoint: APIEndpoint, as type: T.Type) async throws -> Data {
    guard let url = URL(string: endpoint.urlString) else {
      throw APIError.encodingDecodingError
    }
    var request = URLRequest(url: url)
    request.httpMethod = endpoint.method.rawValue
    
    let (data, response) = try await URLSession.shared.data(for: request)
    
   /// ??? don't know what to do with the request...
  }

any reference, or idea would be appreciated.🥲

[stephencelis]

@inwoodev You'll need to convert the data to the decodable type somehow. Assuming it's JSON, you can use a JSONDecoder:

return try JSONDecoder().decode(T.self, from: data)

[inwoodev]

I was trying to figure out ways of converting the method into function propertt so the implementation could be dynamically created, but... I think I will stick with the below approach as the liveValue of the client would differ for all the reducers that uses the client.

import ComposableArchitecture
import Foundation

enum APIError: Error {
  case encodingDecodingError
}

struct APIClient {
  func request<T: Decodable>(endpoint: APIEndpoint, as type: T.Type) async throws -> T {
    guard let url = URL(string: endpoint.urlString) else {
      throw APIError.encodingDecodingError
    }
    var request = URLRequest(url: url)
    request.httpMethod = endpoint.method.rawValue
    
    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONDecoder().decode(T.self, from: data)
  }
}

extension APIClient: DependencyKey {
  static var liveValue: APIClient {
    return Self()
  }
  
}

// MARK: - Dependency
extension DependencyValues {
  var apiClient: APIClient {
    get { self[APIClient.self] }
    set { self[APIClient.self] = newValue}
  }
}

[inwoodev]

@stephencelis

Thank you. I think I was very sleepy at the very moment when I asked the question. With your enlightenment and with clear mind, I was able to figure it out:) Thank you again~

import ComposableArchitecture
import Foundation

enum APIError: Error {
  case encodingDecodingError
}

struct APIClient {
  var _request: (APIEndpoint) async throws -> Data
  
  func request<T: Decodable>(endpoint: APIEndpoint, as type: T.Type) async throws -> T {
    return try await JSONDecoder().decode(T.self, from: self._request(endpoint))
  }
}

extension APIClient: DependencyKey {
  static var liveValue: APIClient {
    return Self(
      _request: { endpoint in
        guard let url = URL(string: endpoint.urlString) else {
          throw APIError.encodingDecodingError
        }
        var request = URLRequest(url: url)
        request.httpMethod = endpoint.method.rawValue
        
        let (data, _) = try await URLSession.shared.data(for: request)
        return data
      })
  }
  
}

// MARK: - Dependency
extension DependencyValues {
  var apiClient: APIClient {
    get { self[APIClient.self] }
    set { self[APIClient.self] = newValue}
  }
}

[acosmicflamingo]

There's been a few occasions when consulting with my pillow was the best way to debug issues :)