protocols.swift

 @discardableResult
    public func mutate<T: GraphQLMutation>(_ mutation: T,
                                           completion: @escaping RequestResult<GQLResponse<T.Data>>) -> Cancellable
    {
        
        DispatchQueue.main.async {
            UIApplication.shared.isNetworkActivityIndicatorVisible = true
        }
        
        return gqlClient.perform(mutation: mutation) { (result, error) in
        
            self.add(graphQLOperationWithId: mutation.id)
            
            self.handleGQLResponse(operation: mutation,
                                   result: result,
                                   error: error as? GraphQLHTTPResponseError,
                                   completion: completion)
            
        }
        
    }
    
    // MARK: - Private Methods
    
    fileprivate func handleGQLResponse<T: GraphQLOperation>(operation: T,
                                                            result: GraphQLResult<T.Data>?,
                                                            error: GraphQLHTTPResponseError?,
                                                            completion: @escaping RequestResult<GQLResponse<T.Data>>)
    {
        
        DispatchQueue.main.async {
            UIApplication.shared.isNetworkActivityIndicatorVisible = false
        }

        if let error = error {
            
            let statusCode = error.response.statusCode
            
            // TODO: Implement retry logic
            
            if operation.operationType == .query {
                self.query(operation, completion: completion)
            } else if operation.operationType == .mutation {
                self.mutate(operation, completion: completion)
            }
            
            completion(.failure(error))
            return
            
        }

        remove(graphQLOperationWithId: operation.id)
        
        if let gqlError = result?.errors?.first {
            
            let e = Error.graphQLErrorEnum(forGraphQLError: gqlError) as Error

            completion(.failure(e))
            return

        }

        if let data = result?.data {
            
            let r = GQLResponse(data: data, cacheHit: result?.source == .cache)

            completion(.success(r))
            return

        } else {

            completion(.failure(Error.gqlError(.emptyResponse)))
            return

        }
 
    }