fix: Interceptor 로직 개선

여러 API를 동시에 호출할 때 토큰 갱신 로직이 중복 호출될 수 있는 문제를 개선했습니다.
스레드 안정성을 개선했습니다.

Author: hgjwilly-koreatech

Koin/Data/Service/Network/Interceptor.swift

@@ -14,33 +14,79 @@ final class Interceptor: RequestInterceptor {
     private let retryLimit = 1
     private var subscriptions: Set<AnyCancellable> = []
 
+    private let lock = NSLock()
+    @Published private var isRefreshing = false
+    
     func adapt(_ urlRequest: URLRequest,
                for session: Session,
                completion: @escaping (Result<URLRequest, any Error>) -> Void) {
 
-        var urlRequest = urlRequest
-        if let token = KeychainWorker.shared.read(key: .access) {
-            urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+        
+        switch isRefreshing {
+        case true:
+            $isRefreshing
+                .filter { $0 == false }
+                .first()
+                .sink { _ in
+                    var urlRequest = urlRequest
+                    if let token = KeychainWorker.shared.read(key: .access) {
+                        urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+                    }
+                    completion(.success(urlRequest))
+                }
+                .store(in: &subscriptions)
+        case false:
+            var urlRequest = urlRequest
+            if let token = KeychainWorker.shared.read(key: .access) {
+                urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+            }
+            completion(.success(urlRequest))
         }
-        completion(.success(urlRequest))
     }
 
     func retry(_ request: Request,
                for session: Session,
                dueTo error: any Error,
                completion: @escaping @Sendable (RetryResult) -> Void) {
 
-        guard let responseCode = error.asAFError?.responseCode,
+        guard let responseCode = request.response?.statusCode,
               responseCode == 401,
               request.retryCount < retryLimit,
               let _ = KeychainWorker.shared.read(key: .refresh) else {
             completion(.doNotRetryWithError(error))
             return
         }
 
-        refreshToken().sink( receiveValue: { isRefreshed in
-            completion(isRefreshed ? .retry : .doNotRetryWithError(error))
-        }).store(in: &subscriptions)
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+        
+        switch isRefreshing {
+        case true:
+            $isRefreshing
+                .filter { $0 == false }
+                .first()
+                .sink { _ in
+                    completion(.retry)
+                }
+                .store(in: &subscriptions)
+        case false:
+            isRefreshing = true
+            refreshToken().sink( receiveValue: { [weak self] isRefreshed in
+                guard let self else { return }
+                
+                lock.lock()
+                isRefreshing = false
+                lock.unlock()
+                
+                completion(isRefreshed ? .retry : .doNotRetryWithError(error))
+            }).store(in: &subscriptions)
+        }
     }
 }