CODEWITHSUNDEEP
rx-swift
milczi
milczi

Reputation: 7572

RxSwift form validation and sending request in one stream

I have a case where I would like to validate form and then if everything is ok go to api request.

I've written some code and it works fine but errors dispose my stream. I know I could add .catch error at the end of flat map but then next flat map would be executed.

Can I add catch error at the end of stream without disposing it? Or the only way to deal with it is separate it to two streams validation and server responses?

        enum Response {
            case error(message: String)
            case success
        }

        let start = input.validate
            .withLatestFrom(input.textFields)
            .flatMap { [unowned self] fields -> Observable<String> in
                return self.validate(characters: fields)
            }
        .flatMapLatest { [unowned self] code -> Observable<String> in
            return self.apiClient.rxSendData(code)
                .retry(1)
        }
        .map { _ in return Response.success }
        .asDriver { Driver.just(Response.error(message: $0.localizedDescription)) }

Upvotes: 1

Views: 373

Answers (2)

Adam H.
Adam H.

Reputation: 680

Have you considered the materialize operator? It converts an observable sequence into an observable sequence of event objects detailing what happened that cannot error but completes when the input sequence completes. You can then share that.

Something like:

let code = input.validate
    .withLatestFrom(input.textFields)
    .flatMap { [unowned self] fields -> Observable<String> in
        self.validate(characters: fields)
            .materialize()
    }
    .share(replay: 1)

code
    .compactMap { $0.error }
    .subscribe() // Show error from `self.validate`
    .disposed(by: bag)

let request = code
    .compactMap { $0.element }
    // Will get to this flat map only if `self.validate` did not error
    .flatMapLatest { [unowned self] code -> Observable<String> in
        self.apiClient.rxSendData(code)
            .retry(1)
            .materialize()
    }
    .share(replay: 1)

request
    .compactMap { $0.error }
    .subscribe() // Show error from `self.apiClient.rxSendData`
    .disposed(by: bag)

request
    .compactMap { $0.element }
    // Do something as a result of the request being successful

The chains would not cease upon self.validate and self.apiClient.rxSendData emitting errors.

Upvotes: 1

Daniel T.
Daniel T.

Reputation: 33967

I'm making some assumptions about code you aren't showing. Your validate function is especially odd to me. It looks like it emits a String (which is ignored, if validation was successful and doesn't emit anything (or maybe an error) if validation failed?

let start = input.validate
    .withLatestFrom(input.textFields)
    .flatMapLatest { [unowned self] fields -> Observable<String> in
        return self.validate(characters: fields)
            .catchError { _ in Observable.empty() } // empty() doesn't emit a value so the next flatMap won't be executed.
    }
    .flatMapLatest { [unowned self] _ -> Observable<Response> in
        return self.apiClient.rxSendData()
            .retry(1)
            .map { _ in Response.success }
            .catchError { error in Observable.just(Response.error(message: error.localizedDescription)) }
    }
    .asDriver { Driver.just(Response.error(message: $0.localizedDescription)) }

If validate emits an error when validation fails, and you want to capture that error, then something like this would work:

let start = input.validate
    .withLatestFrom(input.textFields)
    .flatMapLatest { [unowned self] fields -> Observable<Response> in
        return self.validate(characters: fields)
            .map { _ in Response.success }
            .catchError { Observable.just(Response.error(message: $0.localizedDescription)) }
    }
    .flatMapLatest { [unowned self] validation -> Observable<Response> in
        // here, the above flatMap emits a value no matter what, so we have to switch on it to determine if we want to continue or just push the Response down the pipe.
        switch validation {
            case .error:
                return Observable.just(validation)
            case .success:
                return self.apiClient.rxSendData()
                    .retry(1)
                    .map { _ in Response.success }
                    .catchError { error in Observable.just(Response.error(message: error.localizedDescription)) }
        }
    }
    .asDriver { Driver.just(Response.error(message: $0.localizedDescription)) }

Upvotes: 1

Related Questions