Moya와 Swift Concurrency

iOS 개발에서 네트워크 요청을 처리할 때, URLSession을 직접 사용하는 것은 번거로운 작업이 될 수 있습니다. 이를 더 간결하고 효율적으로 만들기 위해 많은 개발자들이 Moya를 활용하고 있습니다. Moya는 Alamofire 기반의 네트워크 라이브러리로, API 요청을 보다 구조적으로 관리할 수 있도록 도와줍니다.

하지만 기존 Moya는 completion handler 기반의 비동기 처리를 사용하기 때문에, Swift의 최신 Concurrency(비동기/동시성) 기능과 자연스럽게 어울리지 않는 문제가 있습니다. 다행히도, Swift의 async/await을 활용하면 네트워크 요청을 훨씬 더 직관적으로 작성할 수 있으며, 가독성과 유지보수성을 크게 향상시킬 수 있습니다.

이 글에서는 Moya와 Swift Concurrency를 결합하여 네트워크 요청을 더욱 깔끔하고 효율적으로 처리하는 방법을 소개합니다. withCheckedContinuation과 withCheckedThrowingContinuation을 활용하여 기존 Moya의 completion 기반 API를 async/await 방식으로 변환하는 방법을 알아보고, 에러 핸들링을 보다 유연하게 처리할 수 있는 전략도 함께 다뤄보겠습니다. 🚀

🟡 1. Concurrency 함수.

1. withCheckedContinuation

✅ 기본적으로 Result 타입을 사용하지 않는 비동기 함수 변환에 사용

• 비동기 함수가 오류를 던지지 않는 경우(Result 타입이나 Error를 사용하지 않는 경우)
• continuation.resume(returning:)을 사용해 값을 반환

사용예시

func fetchData(completion: @escaping (String) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        completion("Hello, Swift Concurrency!")
    }
}

func fetchDataAsync() async -> String {
    return await withCheckedContinuation { continuation in
        fetchData { result in
            continuation.resume(returning: result)
        }
    }
}

Task {
    let result = await fetchDataAsync()
    print(result)  // "Hello, Swift Concurrency!"
}

📌 설명

• fetchData(completion:)은 기존의 콜백 기반 함수
• fetchDataAsync()에서 withCheckedContinuation을 사용해 async 함수로 변환
• continuation.resume(returning:)을 호출해 데이터를 async 함수의 결과로 반환

---

2. withCheckedThrowingContinuation

✅ 오류를 던지는 비동기 함수 변환에 사용

• completionHandler가 Result<T, Error> 또는 (T?, Error?) 형태로 값을 반환하는 경우 적합
• continuation.resume(throwing:)을 사용해 오류 전달 가능

사용예시

enum NetworkError: Error {
    case invalidResponse
}

func fetchDataWithError(completion: @escaping (String?, Error?) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        let success = Bool.random()
        if success {
            completion("Success Data", nil)
        } else {
            completion(nil, NetworkError.invalidResponse)
        }
    }
}

func fetchDataAsyncWithError() async throws -> String {
    return try await withCheckedThrowingContinuation { continuation in
        fetchDataWithError { result, error in
            if let error = error {
                continuation.resume(throwing: error)  // 오류 전달
            } else if let result = result {
                continuation.resume(returning: result)  // 정상 데이터 반환
            } else {
                continuation.resume(throwing: NetworkError.invalidResponse)  // 예외 처리
            }
        }
    }
}

Task {
    do {
        let result = try await fetchDataAsyncWithError()
        print(result)  
    } catch {
        print("Error:", error)
    }
}

📌 설명

• fetchDataWithError(completion:)은 성공/실패 여부에 따라 데이터를 반환하는 기존의 콜백 기반 함수
• fetchDataAsyncWithError()에서는 withCheckedThrowingContinuation을 사용해 async/await 버전으로 변환
• continuation.resume(throwing:)을 사용해 오류를 던짐

---

3. withCheckedContinuation vs withCheckedThrowingContinuation 차이점

	withCheckedContinuation	withCheckedThrowingContinuation
오류 처리	Error를 던질 수 없음	Error를 던질 수 있음
resume 방식	continuation.resume(returning:)	continuation.resume(returning:) 또는 continuation.resume(throwing:)
사용 예시	단순 비동기 콜백 변환	Result<T, Error> 또는 (T?, Error?) 형태의 비동기 처리

---

4. 사용 시 주의할 점 🚨

1. resume(_:)은 반드시 한 번만 호출해야 함

   • resume(returning:) 또는 resume(throwing:)을 두 번 이상 호출하면 런타임 오류 발생
   • 예제에서 if let / else if let을 사용하여 중복 호출 방지

2. Completion Handler 기반 API가 여러 번 호출되지 않는지 확인

   • 일부 API는 여러 번 completion을 호출할 수 있음 → 직접 방어 코드 추가 필요
   • 예를 들어 URLSession의 dataTask(with:)는 네트워크 요청이 취소되었을 때도 completion을 호출할 수 있음

---

🟢 2. Moya + aysnc-await

1. Moya 라이브러리의 핵심 메서드.

Moya 라이브러리의 request 함수는 네트워크 요청을 수행하는 핵심 메서드입니다.
이 함수는 TargetType을 기반으로 API 요청을 만들고, 결과를 completion 클로저를 통해 반환합니다.

함수 원형

open func request(
    _ target: Target, 
    callbackQueue: DispatchQueue? = .none, 
    progress: ProgressBlock? = .none, 
    completion: @escaping Completion
) -> Cancellable

매개변수

매개변수	타입	설명
target	Target	요청할 API의 대상(TargetType을 따르는 타입)
callbackQueue	DispatchQueue?	응답을 처리할 큐 (기본값 nil → 내부적으로 적절한 큐 사용)
progress	ProgressBlock?	다운로드/업로드 진행 상태를 추적할 클로저 (기본값 nil)
completion	@escaping Completion	요청 완료 후 호출되는 클로저 (Result<Response, MoyaError> 형태의 결과 반환)

반환값

• Cancellable : 요청을 취소할 수 있는 객체를 반환
  (cancel()을 호출하면 네트워크 요청을 중단할 수 있음)

---

2. MoyaProvider Extension

import Moya

extension MoyaProvider {
	func request(
        _ target: Target, 
        callbackQueue: DispatchQueue? = .none, 
        progress: ProgressBlock? = .none, 
        completion: @escaping Completion
    ) async -> Result<Moya.Response, MoyaError> {
    	await withCheckContinuation { continuation in 
        	self.request(
            	target, 
                callbackQueue: callbackQueue, 
                progress: progress,
            ) { result in 
            	continuation.resume(returning: result)
            }
        }
    }
}

📌 설명

• withCheckedContinuation을 사용하여 네트워크 요청을 async 방식으로 변환
• 기존 Moya의 Completion 타입(Result<Response, MoyaError>)을 그대로 반환
• throw 없이 Result 타입으로 결과를 전달하므로, 네트워크 계층에서 한 번 더 에러 핸들링 가능

---

3. 네트워크 모듈에서 에러 핸들링

네트워크 요청을 수행한 후, Result를 활용하여 에러를 모듈 내부에서 한 번 더 가공하도록 합니다.

class Network {
    /// 네트워크 요청을 수행하고, 내부에서 에러 핸들링한 후 반환
    func task<T: Decodable, E: TargetType>(_ target: E) async throws -> T {
        let provider: MoyaProvider<E> = .init()
        let result = await provider.request(target)
        let parsed = self.parsing(T.self, result: result)
        
        switch parsed {
        case .success(let response):
            return .success(response)
        case .failure(let moyaError):
            let networkError = self.moyaError(moyaError)
            throw networkError
        }
    }
    
    /// MoyaError → NetworkError로 변환하는 메서드
    private func moyaError(_ error: MoyaError) -> NetworkError {
        switch error {
        case .statusCode(let response):
            return .serverError(response.statusCode)
        case .underlying(let nsError, _):
            return .networkFailure(nsError.localizedDescription)
        case .requestMapping, .parameterEncoding, .jsonMapping:
            return .invalidRequest
        @unknown default:
            return .unknown
        }
    }
    
    /// JSON Data를 파싱하는 메서드
    private func parsing<T: Decodable>(_ type: T.Type, result: <Moya.Response, MoyaError>) -> Reseult<T, MoyaError> {
    	switch result {
        case .success(let response):
        	if let data = try? JSONDecoder().decode(type, from: response.data) {
            	return .success(data)
            } else {
            	return .failuer(.jsonMapping(response))
            }
        case .failure(let moyaError):
        	return .failure(moyaError)
        }
    }
}

/// 커스텀 네트워크 에러 정의
enum NetworkError: Error {
    case serverError(Int)  // 서버 상태 코드 오류
    case networkFailure(String)  // 네트워크 실패 (인터넷 연결 문제 등)
    case invalidRequest  // 잘못된 요청
    case unknown  // 알 수 없는 오류
}

📌 설명

• Network를 통해 MoyaProvider를 감싸서 에러를 한 번 더 처리하는 계층을 만듦
• task(_:)에서 request(_:) 호출 후 Result<Response, MoyaError>를 디코딩 타입으로 변환하여 리턴 또는 MoyaError를 NetworkError로 매핑하여 throw
• parsing(_:result:)를 통해 Response를 T.Type으로 디코딩
• moyaError(_:)을 통해 MoyaError를 NetworkError로 매핑

4. 사용 예제

let network = Network()

Task {
	do {
    	let target: API = .getUserName(id: 124)
    	let value: String = try await network.task(target)
    	
        print("✅ 유저 이름: \(value)")
    } catch {
        print("❌ 네트워크 오류: \(error)")    
    }
}

📌 설명

• network.task(target)을 호출하면 T.Type을 반환
• do-try-catch문을 사용해 네트워크 응답을 처리
• NetworkError로 변환된 에러를 catch하여 더 명확한 오류 메시지를 제공

---

✅ 3. 정리

• 이 방식은 네트워크 모듈에서 에러를 한 번 더 가공할 수 있어 확장성이 뛰어납니다.
• async/await을 사용하면서도 보다 체계적으로 에러 처리를 하고 싶다면 적절한 선택이 될 것입니다! 🚀