Introducing delegate if there is GraphQL errors

[kimdv]

The idea of this delegate is based on

• https://github.com/apollographql/apollo-link/tree/master/packages/apollo-link-error
• https://blog.apollographql.com/full-stack-error-handling-with-graphql-apollo-5c12da407210

It adds ability for better error handling on the clients when there is Graphql errors
Etc when a token is expired.

The diffrent from this delegate and HTTPNetworkTransportRetryDelegate is that some errors might come from the GraphQL API and not from middleware etc.

• Add tests

[designatednerd]

Like this idea! Would love to see some tests on it please 😃

[kimdv]

Will create tests when we can mock. Depending on #767

[designatednerd]

@kimdv #767 is finally merged if you wanna use the stuff from that still

[designatednerd]

this is more of a note to self than to you: I need to add my readability isNotEmpty boolean extension to this code 🙃

[designatednerd]

Done in #872

[kimdv]

@designatednerd I rebased and added two tests. One with error and one with none.

[kimdv]

@designatednerd I rebased and added two tests. One with error and one with none.
I'm not sure that the tests are good enough. If not, please send some hints! 🚀

I also noticed tests are not executed randomly.
I think it should be enabled as it will prevent tests depend on each other 🔥

[designatednerd]

@kimdv can you merge in and/or rebase off master so the test suite can run on Circle please?

[kimdv]

@designatednerd done!
Let's see what explodes 🔥🙈

[designatednerd]

🎉 Nothing! 🎉 Mergin'

[RolandasRazma]

how do you know if failure after retrying?
if request fails and you call retryHandler(true) and it fails again I don't see how to know that you should just give up

[designatednerd]

That's why we explicitly recommend against just calling retryHandler(true) without any context in the documentation for this method and the retry delegate for network errors.

If you're not looking at the actual errors that have come in, you could easily wind up in an infinite retry loop.

[RolandasRazma]

I'm thinking about case where server say "token invalid", I update token, and server say "still invalid". Correct thing to do is to give up, but I don't know that I already tried to update token

[designatednerd]

It sounds a bit more like a bug in your server if a just-updated token is being rejected as invalid, but you could theoretically add some tracking of what the last (n) errors received were, and if some aspect of them (status code, message, etc) is the same, then stop retrying.

[RolandasRazma]

maybe it's me, but I like to code defensively 🤷‍♂

[designatednerd]

That's fair, but I think the "how do I handle situation x" stuff is more of an application-level decision, so we're letting developers handle that as defensively as they'd like to.

[kimdv]

Hi!
We had the same problem but solved it in the client.

final class GraphQLClient {
    private var retryHandlers = [(Bool) -> Void]()
    private let isolationQueue = DispatchQueue(label: "GraphQLClient.isolationQueue",
                                               qos: .userInitiated,
                                               attributes: [],
                                               autoreleaseFrequency: .workItem,
                                               target: nil)
}

extension GraphQLClient: HTTPNetworkTransportGraphQLErrorDelegate {
    func networkTransport(_ networkTransport: HTTPNetworkTransport, receivedGraphQLErrors errors: [GraphQLError], retryHandler: @escaping (Bool) -> Void) {
        let errors = errors.map { OurGraphQLError(error: $0) }
        
        guard error.contains(.authTokenInvalid) else {
            retryHandler(false)
            return
        }
        
        let isTokenExchangeInProgress = scheduleForExecution(retryHandler: retryHandler)
        if isTokenExchangeInProgress { return }
        
        exchangeRefreshToken { [weak self] result in
            guard let strongSelf = self else { return }
            
            switch result {
            case .success:
                strongSelf.executeRetryHandlers(retry: true)
            
            case .failure(let error):              
                strongSelf.executeRetryHandlers(retry: false)
            }
        }
    }

    private func scheduleForExecution(retryHandler: @escaping (Bool) -> Void ) -> Bool {
        var isTokenExchangeInProgress = true
        isolationQueue.sync {
            isTokenExchangeInProgress = !retryHandlers.isEmpty
            retryHandlers.append(retryHandler)
        }
        return isTokenExchangeInProgress
    }

    private func executeRetryHandlers(retry: Bool) {
        isolationQueue.async { [weak self] in
            guard let strongSelf = self else { return }
            for handler in strongSelf.retryHandlers {
                handler(retry)
            }
            strongSelf.retryHandlers = []
        }
    }
}

In this way we can cancel if refresh token exchange fails.