How to get Error from network request using RxSwift

Question

I have a network request that return an Observable Result, I want only to catch error message as a string so I can merge the error message with another error message. I try to use map from the result to only map out the error, but I can't figure it out how to correctly catch the error.

This is my network manager

class NetworkManager {
    private let baseURL = "https://api.github.com/"
    
    func getFollowers(with username: String, page: Int) -> Observable<Result<[Follower], GFError>> {
        let endpoint = baseURL + "users/\(username)/followers?per_page=100&page=\(page)"
        let url = URL(string: endpoint)!
        
        return Observable.create { (observer) -> Disposable in
            let task = URLSession.shared.dataTask(with: url) { data, response, error in
                if let _ = error {
                    observer.onNext(.failure(.unableToComplete))
                    return
                }
                
                guard let response = response as? HTTPURLResponse, response.statusCode == 200 else {
                    
                    observer.onNext(.failure(.invalidResponse))
                    return
                }
                
                guard let data = data else {
                    observer.onNext(.failure(.invalidData))
                    return
                }
                
                do {
                    let decoder                     = JSONDecoder()
                    decoder.keyDecodingStrategy     = .convertFromSnakeCase
                    decoder.dateDecodingStrategy    = .iso8601
                    
                    let results = try decoder.decode([Follower].self, from: data)
                    observer.onNext(.success(results))
                    observer.onCompleted()
                } catch {
                    observer.onNext(.failure(.invalidData))
                }
            }
            task.resume()
            return Disposables.create {
                task.cancel()
            }
        }
    }

This is my viewModel

protocol ViewModelType {
    associatedtype Input
    associatedtype Output
    
    func transform(input: Input) -> Output
}

class SearchViewModel: ViewModelType {
    
    // MARK: Properties    
    let manager: NetworkManager
            
    // MARK: Binding
    struct Input {
        let searchText: Observable<String>
        let validate: Observable<Void>
    }
    
    struct Output {
        let followers: Driver<Result<[FollowerViewModel], GFError>>
        let errorMessage: Driver<String>
    }
    
    init(manager: NetworkManager) {
        self.manager = manager
    }
    
    func transform(input: Input) -> Output {
        let followers = input.validate
            .withLatestFrom(input.searchText)
            .filter { !$0.isEmpty }
            .flatMapLatest { query in
                return self.manager.getFollowers(with: query, page: 1)
            }.asDriver { error in
                return Driver.just(.failure(error as! GFError))
            }
        
        let missingName = input.validate
            .withLatestFrom(input.searchText)
            .compactMap { $0.isEmpty ? "Please enter a username. We need to know who to look for" : nil }
            .asDriver(onErrorJustReturn: "")
        
        let errorMessage = followers
        
        let followerVM = followers.map { $0.map { $0.map { FollowerViewModel(follower: $0) }}}
        
        return Output(followers: followerVM, errorMessage: errorMessage)
    }
}

Answer 1

Your view model is pretty strong, just a few slight errors. The fact that your network request returns an Observable Result means you need to use compact map and a case let to extract the values. There are libraries that make this easier. One is called RxEnumKit.

class SearchViewModel {

    // MARK: Properties
    let manager: NetworkManager

    // MARK: Binding
    struct Input {
        let searchText: Observable<String>
        let validate: Observable<Void>
    }

    struct Output {
        let followers: Driver<[FollowerViewModel]> // note, this should not return a Driver-result.
        let errorMessage: Driver<String>
    }

    init(manager: NetworkManager) {
        self.manager = manager
    }

    func transform(input: Input) -> Output {
        let followers = input.validate
            .withLatestFrom(input.searchText)
            .filter { !$0.isEmpty }
            .flatMapLatest { query in
                return self.manager.getFollowers(with: query, page: 1)
            }

        let missingName = input.validate
            .withLatestFrom(input.searchText)
            .compactMap { $0.isEmpty ? "Please enter a username. We need to know who to look for" : nil }

        // the below extracts the error string from the followers observable and merges it with the missingName observable to make the errorMessage observable.
        let errorMessage = Observable.merge(
            missingName,
            followers.compactMap { (result) -> String? in
                guard case let .failure(error) = result else { return nil }
                return error.localizedDescription
            }
        )
        .asDriver(onErrorJustReturn: "")

        // use the same thing here to pull the followers out of the Result.
        let followerVM = followers.compactMap { (result) -> [FollowerViewModel]? in
            guard case let .success(followers) = result else { return nil }
            return followers.map { FollowerViewModel(follower: $0) }
        }
        .asDriver(onErrorJustReturn: [])


        return Output(followers: followerVM, errorMessage: errorMessage)
    }
}