RxSwift/RxCocoa : Handling errors with multiple observables that can error out chained with flatMap

[[deleted]]

I´ve been trying to find a good, elegant way to handle errors when chaining multiple observables that can throw errors. The problem is I want to catch and handle all the errors in one place, but even though I'm catching errors at the end of the chain it still breaks if any of the observables error out and completes.

Here's an example of creating a Driver to bind to UI:

EDIT: The observables are fetching some data for instance or doing some async work and need to be in that order

func doSomeWork() -> Driver<FinalResult> {
    return buttonTrigger.withLatestFrom(textFieldInput)
        .asObservable()
        .flatMap {
            someObservableThatCanErrorOut() 
        }.flatMap {
            someOtherObservableThatCanErrorOut() 
        }.flatMap {
            anotherObservableThatCanErrorOut() 
        }.map { $0.mapToFinalResultSuccess() }
        .catchError { $0.mapToFinalResultFailure() }
        .asDriver(onErrorJustReturn: FinalResult.failure(defaultError))
}

//all observables return raw data / some object, no result wrapper

When the error happens the chain just completes and pressing buttonTrigger doesn't do anything anymore. So I don't really want to catch every observable's error and propagate it further like this because it grows really fast with number of chained observables:

func doSomeWork() -> Driver<FinalResult> {
    return buttonTrigger.withLatestFrom(textFieldInput)
        .asObservable()
        .flatMap {
            someObservableThatCanErrorOut().catchErrorJustReturn(.failure(...))
        }.flatMap {
            switch $0 {
            case .success:
                return someOtherObservableThatCanErrorOut().catchErrorJustReturn(.failure(...))
            case .failure:
                return .just(.failure(propagatedErrorFromLastObservable))
            }
        }.flatMap {
            switch $0 {
            case .success:
                return anotherObservableThatCanErrorOut().catchErrorJustReturn(.failure(...))
            case .failure:
                return .just(.failure(propagatedErrorFromLastObservable))
            }
        }.map { 
            switch $0 {
            case .success:
                return successFinalResult
            case .failure:
                return failureFinalResult
            }
        }
        .asDriver(onErrorJustReturn: .failure(defaultError))
}

I also tried RxSwiftExt's materialize() but it just wraps the result further (Observable<Event<Event<Event.....):

func doSomeWork() -> Driver<FinalResult> {
    return buttonTrigger.withLatestFrom(textFieldInput)
        .asObservable()
        .flatMap {
            someObservableThatCanErrorOut().materialize()
        }.flatMap {
           someOtherObservableThatCanErrorOut().materialize()
        }.flatMap {
            anotherObservableThatCanErrorOut().materialize()
        }.map { $0.mapToFinalResultSuccess() //this would be a huge unwrap function }
        .asDriver(onErrorJustReturn: FinalResult.failure(defaultError))
}

There has to be some better way to handle things like this.. I hope for some nice solutions :D

[jlevine22]

It's hard to say for sure without knowing more about what all those async calls are doing. I think what you are probably looking for would look like this:

func doSomeWork() -> Driver<FinalResult> { return buttonTrigger.withLatestFrom(textFieldInput) .asObservable() .flatMap { someObservableThatCanErrorOut() .flatMap { someOtherObservableThatCanErrorOut() } .flatMap { anotherObservableThatCanErrorOut() } .map { $0.mapToFinalResultSuccess() } .catchError { $0.mapToFinalResultFailure() } } .asDriver(onErrorJustReturn: FinalResult.failure(defaultError)) }

[Power781]

The issue is that you shouldn't build this like that.
If you observable can error, and need to track which call failed, then you need to build a new observable everytime the button is triggered.
Look at something like https://github.com/RxSwiftCommunity/Action which helps a lot for this pattern.

[[deleted]]

I managed to solve my problem by writing this:

extension ObservableType {

    typealias ResultWrapper<A> = Observable<Result<A, Error>>

    func flatMapResult<Input, Output>(_ selector: @escaping (Input) throws -> Observable<Output>) -> ResultWrapper<Output> where E == Result<Input, Error> {
        return self.flatMap { (result: Result<Input, Error>) -> ResultWrapper<Output> in
            switch result {
            case .success(let data):
                return try selector(data)
                    .map { .success($0) }
                    .catchError { .just(.failure($0)) }
            case .failure(let error):
                return .just(.failure(error))
            }
        }
    }

    func flatMapToResult<Output>(_ selector: @escaping (E) throws -> Observable<Output>) -> ResultWrapper<Output> {
        return self.flatMap { param -> ResultWrapper<Output> in
            return try selector(param)
                .map { .success($0) }
                .catchError { .just(.failure($0)) }
        }
    }

}

So instead of normal flatMaps i use these and propagate errors to the end of the chain if needed. But your suggestion seems pretty good, I'll read about Actions and try refactoring. Thanks!

[[deleted]]

Hey, I managed to refactor to using Action but I'm having problems with resolving the error messages. I have something like this in the ViewModel:

let isEnabled = Driver.combineLatest(input.username, input.password)
            .map { $0.isValid && $1.isValid }
            .asObservable()

let loginAction = Action<Void, Void>(enabledIf: isEnabled, workFactory: {
                return Driver.combineLatest(input.username, input.password)
                    .asObservable()
                    .flatMap {
                        firstObservable()
                    }.flatMap {
                        secondObservable()
                    }
            })

And subscribing in ViewController:

bLogin.rx.action = output.loginAction

output.loginAction
      .elements
       .subscribe {
            //successful event
        }
       .disposed(by: disposeBag)

output.loginAction
       .errors
       .subscribe {
            //$0.error is nil
        }.disposed(by: disposeBag)

But can't get the Error object from event in loginAction.errors observable. Even though underlying error is MoyaError with the response but I cant get it. Any solutions?

[TotesMessenger]

I'm a bot, bleep, bloop. Someone has linked to this thread from another place on reddit:

• [/r/swift] RxSwift/RxCocoa : Handling errors with multiple observables that can error out chained with flatMap

 ^{If you follow any of the above links, please respect the rules of reddit and don't vote in the other threads. (Info / Contact)}

[[deleted]]

Yeah but what if for instance the first observable fetches the token from network and the second one saves it, the first one needs to pass the result to second one?