[BOOK-72] refactor: remove concurrency remnants

- Removed async/await-based request implementation
- Replaced with Combine publishers and conditional retry logic
- Introduced retryIf operator for controlled retry on specific error

Author: clxxrlove

src/Projects/BKData/Sources/Interface/Network/NetworkProvider.swift

@@ -1,10 +1,11 @@
 // Copyright © 2025 Booket. All rights reserved
 
+import Combine
+
 public protocol NetworkProvider {
     @discardableResult
     func request<T: Decodable>(
         target: RequestTarget,
-        type: T.Type,
-        isRetry: Bool
-    ) async throws -> T
+        type: T.Type
+    ) -> AnyPublisher<T, Error>
 }

src/Projects/BKData/Sources/Interface/Storage/TokenProvider.swift

@@ -2,5 +2,5 @@
 
 public protocol TokenProvider {
     var accessToken: String? { get }
-    func refreshIfNeeded() async throws
+    func refreshIfNeeded()
 }

src/Projects/BKNetwork/Sources/Extension/Data+.swift

@@ -4,24 +4,8 @@ import Foundation
 
 extension Data {
     func decode<T: Decodable>(
-        to type: T.Type,
-        with response: URLResponse
+        to type: T.Type
     ) throws -> T {
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw NetworkError.invalidResponse
-        }
-        
-        switch httpResponse.statusCode {
-        case 200...299:
-            break
-        case 401:
-            throw NetworkError.unauthorized
-        case 500...599:
-            throw NetworkError.internalServerError
-        default:
-            throw NetworkError.invalidResponse
-        }
-
         return try JSONDecoder().decode(T.self, from: self)
     }
 }

src/Projects/BKNetwork/Sources/Extension/Publisher+.swift

@@ -0,0 +1,20 @@
+// Copyright © 2025 Booket. All rights reserved
+
+import Combine
+
+extension Publisher {
+    func retryIf(
+        _ shouldRetry: @escaping (Failure) -> Bool,
+        maxRetries: Int
+    ) -> AnyPublisher<Output, Failure> {
+        self.catch { error -> AnyPublisher<Output, Failure> in
+            guard maxRetries > 0, shouldRetry(error) else {
+                return Fail(error: error).eraseToAnyPublisher()
+            }
+            return self
+                .retryIf(shouldRetry, maxRetries: maxRetries - 1)
+                .eraseToAnyPublisher()
+        }
+        .eraseToAnyPublisher()
+    }
+}

src/Projects/BKNetwork/Sources/Helper/AuthInterceptor.swift

@@ -10,20 +10,23 @@ public struct AuthInterceptor {
         self.tokenProvider = tokenProvider
     }
 
-    func adapt(_ request: URLRequest) throws -> URLRequest {
+    func adapt(_ request: URLRequest) -> URLRequest {
         guard let token = tokenProvider.accessToken else { return request }
 
         var adapted = request
         adapted.addAuthorization(token)
         return adapted
     }
 
-    func retryIfNeeded(_ response: URLResponse?, _ data: Data) async throws -> Bool {
-        guard let httpResponse = response as? HTTPURLResponse else { return false }
+    func retryIfNeeded(
+        _ response: URLResponse,
+        _ data: Data
+    ) throws {
+        let httpResponse = try response.asHTTP
+            .orThrow(NetworkError.invalidResponse)
         if httpResponse.statusCode == 401 {
-            try await tokenProvider.refreshIfNeeded()
-            return true
+            tokenProvider.refreshIfNeeded()
+            throw RetryTrigger()
         }
-        return false
     }
 }

src/Projects/BKNetwork/Sources/Interface/NetworkRequestable.swift

@@ -1,7 +1,17 @@
 // Copyright © 2025 Booket. All rights reserved
 
+import Combine
 import Foundation
 
 public protocol NetworkRequestable {
-    func data(for request: URLRequest) async throws -> (Data, URLResponse)
+    func data(for request: URLRequest) -> AnyPublisher<(Data, URLResponse), Error>
+}
+
+extension URLSession: NetworkRequestable {
+    public func data(for request: URLRequest) -> AnyPublisher<(Data, URLResponse), Error> {
+        self.dataTaskPublisher(for: request)
+            .map { ($0.data, $0.response) }
+            .mapError { $0 as Error }
+            .eraseToAnyPublisher()
+    }
 }

src/Projects/BKNetwork/Sources/Provider/DefaultNetworkProvider.swift

@@ -1,6 +1,7 @@
 // Copyright © 2025 Booket. All rights reserved
 
 import BKData
+import Combine
 import Foundation
 
 public struct DefaultNetworkProvider: NetworkProvider {
@@ -13,11 +14,21 @@ public struct DefaultNetworkProvider: NetworkProvider {
     @discardableResult
     public func request<T: Decodable>(
         target: RequestTarget,
-        type: T.Type,
-        isRetry: Bool = false
-    ) async throws -> T {
-        let request = try target.makeURLRequest()
-        let (data, response) = try await requestor.data(for: request)
-        return try data.decode(to: type, with: response)
+        type: T.Type
+    ) -> AnyPublisher<T, Error> {
+        do {
+            let request = try target.makeURLRequest()
+            return requestor.data(for: request)
+                .tryMap { data, response in
+                    try response.asHTTP
+                        .orThrow(NetworkError.invalidResponse)
+                        .validate()
+                    return try data.decode(to: type)
+                }
+                .eraseToAnyPublisher()
+        } catch {
+            return Fail(error: error)
+                .eraseToAnyPublisher()
+        }
     }
 }

src/Projects/BKNetwork/Sources/Provider/OAuthNetworkProvider.swift

@@ -1,6 +1,7 @@
 // Copyright © 2025 Booket. All rights reserved
 
 import BKData
+import Combine
 import Foundation
 
 public struct OAuthNetworkProvider: NetworkProvider {
@@ -15,16 +16,23 @@ public struct OAuthNetworkProvider: NetworkProvider {
     @discardableResult
     public func request<T: Decodable>(
         target: RequestTarget,
-        type: T.Type,
-        isRetry: Bool = false
-    ) async throws -> T {
-        let adaptedRequest = try interceptor.adapt(target.makeURLRequest())
-        let (data, response) = try await requestor.data(for: adaptedRequest)
-        
-        if try await interceptor.retryIfNeeded(response, data), isRetry == false {
-            return try await request(target: target, type: type, isRetry: true)
+        type: T.Type
+    ) -> AnyPublisher<T, Error> {
+        do {
+            let adaptedRequest = try interceptor.adapt(target.makeURLRequest())
+            return requestor.data(for: adaptedRequest)
+                .tryMap { data, response in
+                    try response.asHTTP
+                        .orThrow(NetworkError.invalidResponse)
+                        .validate()
+                    try interceptor.retryIfNeeded(response, data)
+                    return try data.decode(to: type)
+                }
+                .retryIf({ $0 is RetryTrigger }, maxRetries: 1)
+                .eraseToAnyPublisher()
+        } catch {
+            return Fail(error: error)
+                .eraseToAnyPublisher()
         }
-        
-        return try data.decode(to: type, with: response)
     }
 }

src/Projects/BKStorage/Sources/TokenStorage/KeychainTokenProvider.swift

@@ -16,7 +16,7 @@ public struct KeychainTokenProvider: TokenProvider {
         try? storage.load(for: accessTokenKey)
     }
 
-    public func refreshIfNeeded() async throws {
+    public func refreshIfNeeded() {
         // TODO: Refresh 기능 구현
     }
 }