[CAT-161] Feature: token interceptor를 포함한 API 모듈 수정 (#18)

Projects/Core/APIClient/Interface/Model/TargetTypeInterface.swift → Projects/Core/APIClient/Interface/APIBaseRequestInterface.swift

@@ -10,7 +10,7 @@ import Foundation
 
 import Dependencies
 
-public protocol TargetType {
+public protocol APIBaseRequest {
   var baseURL: String { get }
   var path: String { get }
   var method: HTTPMethod { get }
@@ -20,8 +20,10 @@ public protocol TargetType {
 
 public enum API {
   public static var apiBaseURL: String {
-    guard let baseURL = Bundle.main.object(forInfoDictionaryKey: "BASE_URL") as? String else { fatalError("url missing") }
-    return "https://" + baseURL
+    guard let baseURL = Bundle.main.object(forInfoDictionaryKey: "BASE_URL") as? String else {
+      fatalError("url missing")
+    }
+    return baseURL
   }
 }
 
@@ -42,7 +44,7 @@ public enum RequestParams {
   case body(_ parameter: Encodable)
 }
 
-public extension TargetType {
+public extension APIBaseRequest {
   var contentType: ContentType {
     return .json
   }

Projects/Core/APIClient/Interface/APIClientInterface.swift

@@ -0,0 +1,42 @@
+//
+//  APIClientInterface.swift
+//  APIClient
+//
+//  Created by 김지현 on 8/6/24.
+//  Copyright © 2024 PomoNyang. All rights reserved.
+//
+
+import Foundation
+
+import Logger
+
+import Dependencies
+import DependenciesMacros
+
+@DependencyClient
+public struct APIClient {
+  public var apiRequest: @Sendable (
+    _ request: APIBaseRequest,
+    _ isWithInterceptor: Bool
+  ) async throws -> (Data, URLResponse)
+
+  public func apiRequest<T: Decodable>(
+    request: APIBaseRequest,
+    as: T.Type,
+    isWithInterceptor: Bool = true
+  ) async throws -> T {
+    let (data, _) = try await self.apiRequest(request, isWithInterceptor)
+
+    do {
+      let decodedData = try JSONDecoder().decode(T.self, from: data)
+      return decodedData
+    } catch {
+      throw NetworkError.decodingError
+    }
+  }
+}
+
+extension APIClient: TestDependencyKey {
+  public static let previewValue = Self()
+  public static let testValue = Self()
+}

Projects/Core/APIClient/Interface/Model/NetworkError.swift

@@ -9,33 +9,39 @@
 import Foundation
 
 public enum NetworkError: Error {
-    case requestError(_ description: String)
-    case noResponseError
-    case authorizationError
-    case decodingError
-    case serverError
-    case networkConnectionError
-    case timeOutError
-    case unknownError
+  case requestError(_ description: String)
+  case apiError(_ description: String)
+  case noResponseError
+  case authorizationError
+  case decodingError
+  case serverError
+  case networkConnectionError
+  case timeOutError
+  case unknownError
+  case refreshTokenExpired
 
-    var errorMessage: String {
-        switch self {
-        case let .requestError(description):
-            return "Request Error: \(description)"
-        case .decodingError:
-            return "Decoding Error"
-        case .serverError:
-            return "Server Error"
-        case .networkConnectionError:
-            return "Network Connection Error"
-        case .timeOutError:
-            return "Timeout Error"
-        case .unknownError:
-            return "Unknown Error"
-        case .noResponseError:
-            return "No Response Error"
-        case .authorizationError:
-            return "Autorization Error"
-        }
+  public var errorMessage: String {
+    switch self {
+    case let .requestError(description):
+      return "Request Error: \(description)"
+    case let .apiError(description):
+      return "API Error: \(description)"
+    case .decodingError:
+      return "Decoding Error"
+    case .serverError:
+      return "Server Error"
+    case .networkConnectionError:
+      return "Network Connection Error"
+    case .timeOutError:
+      return "Timeout Error"
+    case .unknownError:
+      return "Unknown Error"
+    case .noResponseError:
+      return "No Response Error"
+    case .authorizationError:
+      return "Autorization Error"
+    case .refreshTokenExpired:
+      return "Refresh Token has been expired Error"
     }
+  }
 }

Projects/Core/APIClient/Sources/TargetType.swift → Projects/Core/APIClient/Sources/APIBaseRequest.swift

@@ -8,31 +8,23 @@
 
 import Foundation
 import APIClientInterface
-import KeychainClientInterface
 import Shared
 
-
-extension TargetType {
-  func asURLRequest(keychainClient: KeychainClient) async throws -> URLRequest {
-    let url = URL(string: baseURL)!
-    var urlRequest = URLRequest(url: url.appendingPathComponent(path))
+extension APIBaseRequest {
+  func asURLRequest() async throws -> URLRequest {
+    let baseURL = URL(string: "https://\(self.baseURL)")!
+    var urlRequest = URLRequest(url: baseURL.appendingPathComponent(path))
     urlRequest.httpMethod = method.rawValue
     urlRequest.setValue(
       contentType.rawValue,
       forHTTPHeaderField: HTTPHeaderField.contentType.rawValue
     )
-    if let jwt = keychainClient.read(key: "jwt") {
-      urlRequest.addValue(
-        jwt,
-        forHTTPHeaderField: HTTPHeaderField.authentication.rawValue
-      )
-    }
 
     switch parameters {
     case .query(let request):
       let params = try request.toDictionary()
       let queryParams = params.map { URLQueryItem(name: $0.key, value: "\($0.value)") }
-      var components = URLComponents(string: url.appendingPathComponent(path).absoluteString)
+      var components = URLComponents(string: baseURL.appendingPathComponent(path).absoluteString)
       components?.queryItems = queryParams
       urlRequest.url = components?.url
 
@@ -57,7 +49,7 @@ extension TargetType {
   }
 }
 
-public extension TargetType {
+public extension APIBaseRequest {
   var contentType: ContentType {
     return .json
   }

Projects/Core/APIClient/Sources/APIClient.swift

@@ -0,0 +1,86 @@
+//
+//  APIClient.swift
+//  APIClient
+//
+//  Created by 김지현 on 8/6/24.
+//  Copyright © 2024 PomoNyang. All rights reserved.
+//
+
+import Foundation
+
+import Logger
+import APIClientInterface
+
+import Dependencies
+
+extension APIClient: DependencyKey {
+  public static let liveValue: APIClient = .live()
+
+  public static func live() -> Self {
+
+    actor Session {
+      nonisolated let tokenInterceptor: TokenInterceptor
+
+      let session: URLSession = {
+        let config = URLSessionConfiguration.default
+        return URLSession(configuration: config)
+      }()
+
+      let decoder: JSONDecoder = JSONDecoder()
+
+      init(tokenInterceptor: TokenInterceptor) {
+        self.tokenInterceptor = tokenInterceptor
+      }
+
+      func sendRequest(
+        _ request: APIBaseRequest,
+        isWithInterceptor: Bool,
+        retryCnt: Int = 0
+      ) async throws -> (Data, URLResponse) {
+        guard retryCnt < 3 else { throw throwNetworkErr(.timeOutError) }
+
+        var urlRequest = try await request.asURLRequest()
+        if isWithInterceptor {
+          urlRequest = try await tokenInterceptor.adapt(urlRequest)
+        }
+        Logger.shared.log(category: .network, "API Request:\n\(dump(urlRequest))")
+
+        let (data, response) = try await session.data(for: urlRequest)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+          let error = NetworkError.noResponseError
+          Logger.shared.log(level: .error, category: .network, "API Error:\n\(dump(error))")
+          throw error
+        }
+
+        switch httpResponse.statusCode {
+        case 200..<300:
+          return (data, response)
+        case 401:
+          try await tokenInterceptor.retry(for: self.session)
+          return try await sendRequest(request, isWithInterceptor: isWithInterceptor, retryCnt: retryCnt + 1)
+        case 400..<500:
+          throw throwNetworkErr(.requestError("bad request"))
+        case 500..<600:
+          throw throwNetworkErr(.serverError)
+        default:
+          throw throwNetworkErr(.unknownError)
+        }
+
+        func throwNetworkErr(_ error: NetworkError) -> NetworkError {
+          Logger.shared.log(level: .error, category: .network, "\(error.localizedDescription):\n\(dump(error))")
+          return error
+        }
+      }
+    }
+
+    let tokenInterceptor = TokenInterceptor()
+    let session = Session(tokenInterceptor: tokenInterceptor)
+
+    return .init(
+      apiRequest: { request, isWithInterceptor in
+        return try await session.sendRequest(request, isWithInterceptor: isWithInterceptor)
+      }
+    )
+  }
+}