Moya rxswift: обновить токен и перезапустить запрос

Вы можете выполнить перечисление при ошибке и вернуть тип String из вашего flatMap. Если запрос выполнен успешно, он вернет строку, иначе вернет наблюдаемую ошибку

public func retryWithAuthIfNeeded(sessionServiceDelegate: SessionProtocol) -> Observable<E> {
    return self.retryWhen { (error: Observable<Error>) -> Observable<String> in
        return error.enumerated().flatMap { (index, error) -> Observable<String> in
            guard let moyaError = error as? MoyaError, let response = moyaError.response, index <= 3  else {
                throw error
            }
            if response.statusCode == 401 || response.statusCode == 403 {
                // Force logout after failed attempt
                sessionServiceDelegate.doLogOut()
                return Observable.error(error)
            } else {
                return sessionServiceDelegate
                    .getTokenObservable()!
                    .filterSuccessfulStatusAndRedirectCodes()
                    .mapString()
                    .flatMapLatest { (responseString: String) -> Observable<String> in
                        sessionServiceDelegate.refreshToken(responseString: responseString)
                        return Observable.just(responseString)
                    }
            }
        }
    }

Наконец, я смог решить эту проблему, выполнив следующие действия:

Сначала создайте такой протокол (эти функции являются обязательными, а не дополнительными).

import RxSwift
            
public protocol SessionProtocol {
    func getTokenRefreshService() -> Single<Response>
    func didFailedToRefreshToken()
    func tokenDidRefresh (response : String)
}

Очень-очень важно соответствовать протоколу SessionProtocol в классе, в котором вы пишете свой сетевой запрос (-ы) следующим образом:

import RxSwift
    
class API_Connector : SessionProtocol {
        //
        private final var apiProvider : APIsProvider<APIs>!
        
        required override init() {
            super.init()
            apiProvider = APIsProvider<APIs>()
        }
        // Very very important
        func getTokenRefreshService() -> Single<Response> {
             return apiProvider.rx.request(.doRefreshToken())
        }
        
        // Parse and save your token locally or do any thing with the new token here
        func tokenDidRefresh(response: String) {}
        
        // Log the user out or do anything related here
        public func didFailedToRefreshToken() {}
        
        func getUsers (page : Int, completion: @escaping completionHandler<Page>) {
            let _ = apiProvider.rx
                .request(.getUsers(page: String(page)))
                .filterSuccessfulStatusAndRedirectCodes()
                .refreshAuthenticationTokenIfNeeded(sessionServiceDelegate: self)
                .map(Page.self)
                .subscribe { event in
                    switch event {
                    case .success(let page) :
                        completion(.success(page))
                    case .error(let error):
                        completion(.failure(error.localizedDescription))
                    }
                }
        }
        
}

Затем я создал функцию, которая возвращает Single<Response>.

import RxSwift
    
extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
        
        // Tries to refresh auth token on 401 error and retry the request.
        // If the refresh fails it returns an error .
        public func refreshAuthenticationTokenIfNeeded(sessionServiceDelegate : SessionProtocol) -> Single<Response> {
            return
                // Retry and process the request if any error occurred
                self.retryWhen { responseFromFirstRequest in
                    responseFromFirstRequest.flatMap { originalRequestResponseError -> PrimitiveSequence<SingleTrait, ElementType> in
                            if let lucidErrorOfOriginalRequest : LucidMoyaError = originalRequestResponseError as? LucidMoyaError {
                            let statusCode = lucidErrorOfOriginalRequest.statusCode!
                            if statusCode == 401 {
                                // Token expired >> Call refresh token request
                                return sessionServiceDelegate
                                    .getTokenRefreshService()
                                    .filterSuccessfulStatusCodesAndProcessErrors()
                                    .catchError { tokeRefreshRequestError -> Single<Response> in
                                        // Failed to refresh token
                                        if let lucidErrorOfTokenRefreshRequest : LucidMoyaError = tokeRefreshRequestError as? LucidMoyaError {
                                            //
                                            // Logout or do any thing related
                                            sessionServiceDelegate.didFailedToRefreshToken()
                                            //
                                            return Single.error(lucidErrorOfTokenRefreshRequest)
                                        }
                                        return Single.error(tokeRefreshRequestError)
                                    }
                                    .flatMap { tokenRefreshResponseString -> Single<Response> in
                                        // Refresh token response string
                                        // Save new token locally to use with any request from now on
                                        sessionServiceDelegate.tokenDidRefresh(response: try! tokenRefreshResponseString.mapString())
                                        // Retry the original request one more time
                                        return self.retry(1)
                                }
                            }
                            else {
                                // Retuen errors other than 401 & 403 of the original request
                                return Single.error(lucidErrorOfOriginalRequest)
                            }
                        }
                        // Return any other error
                        return Single.error(originalRequestResponseError)
                    }
            }
        }
}

Что делает эта функция, так это то, что она улавливает ошибку из ответа, а затем проверяет код состояния. Если это что-то другое, кроме 401, она вернет эту ошибку в блок onError исходного запроса, но если это 401 (вы можете изменить его чтобы удовлетворить ваши потребности, но это стандарт), тогда он будет выполнять запрос токена обновления.

После выполнения запроса токена обновления он проверяет ответ.

= ›Если код состояния больше или равен 400, это означает, что запрос токена обновления тоже не удался, поэтому верните результат этого запроса в исходный блок OnError запроса. = ›Если код состояния находится в диапазоне 200..300, это означает, что запрос на обновление токена выполнен успешно, следовательно, он повторит исходный запрос еще раз, если исходный запрос снова завершится ошибкой, тогда сбой перейдет к блоку OnError как обычно.

Примечания:

= ›Очень важно проанализировать и сохранить новый токен после того, как запрос токена обновления будет успешным и будет возвращен новый токен, поэтому при повторении исходного запроса он будет делать это с новым токеном, а не со старым.

Ответ токена возвращается в этом обратном вызове прямо перед повторением исходного запроса. func tokenDidRefresh (response : String)

= ›В случае сбоя запроса на обновление токена может случиться так, что срок действия токена истек, поэтому в дополнение к тому, что сбой перенаправляется на onError исходного запроса, вы также получаете этот обратный вызов ошибки func didFailedToRefreshToken(), вы можете использовать его, чтобы уведомить пользователя о том, что его сеанс потеряно или выйти из системы, или что-то в этом роде.

= ›Очень важно вернуть функцию, которая выполняет запрос токена, потому что это единственный способ, которым функция refreshAuthenticationTokenIfNeeded знает, какой запрос вызвать для выполнения токена обновления.

func getTokenRefreshService() -> Single<Response> {
    return apiProvider.rx.request(.doRefreshToken())
}

Вместо написания расширения для Observable есть другое решение. Он написан на чистом RxSwift и в случае неудачи возвращает классическую ошибку.

Простой способ обновить токен сеанса Auth0 с помощью RxSwift и Moya

Основным преимуществом решения является то, что оно может быть легко применимо для различных сервисов, подобных Auth0, позволяющих аутентифицировать пользователей в мобильных приложениях.