请求链自定义

1
import Foundation
2
import Apollo
3

4
class UserManagementInterceptor: ApolloInterceptor {
5
  enum UserError: Error {
6
    case noUserLoggedIn
7
  }
8

9
  public var id: String = UUID().uuidString
10

11
  /// Helper function to add the token then move on to the next step
12
  private func addTokenAndProceed<Operation: GraphQLOperation>(
13
    _ token: Token,
14
    to request: HTTPRequest<Operation>,
15
    chain: RequestChain,
16
    response: HTTPResponse<Operation>?,
17
    completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
18
  ) {
19
    request.addHeader(name: "Authorization", value: "Bearer \(token.value)")
20
    chain.proceedAsync(
21
      request: request,
22
      response: response,
23
      interceptor: self,
24
      completion: completion
25
    )
26
  }
27

28
  func interceptAsync<Operation: GraphQLOperation>(
29
    chain: RequestChain,
30
    request: HTTPRequest<Operation>,
31
    response: HTTPResponse<Operation>?,
32
    completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
33
  ) {
34
    guard let token = UserManager.shared.token else {
35
      // In this instance, no user is logged in, so we want to call
36
      // the error handler, then return to prevent further work
37
      chain.handleErrorAsync(
38
        UserError.noUserLoggedIn,
39
        request: request,
40
        response: response,
41
        completion: completion
42
      )
43
      return
44
    }
45

46
    // If we've gotten here, there is a token!
47
    if token.isExpired {
48
      // Call an async method to renew the token
49
      UserManager.shared.renewToken { [weak self] tokenRenewResult in
50
        guard let self = self else {
51
            return
52
        }
53

54
        switch tokenRenewResult {
55
        case .failure(let error):
56
          // Pass the token renewal error up the chain, and do
57
          // not proceed further. Note that you could also wrap this in a
58
          // `UserError` if you want.
59
          chain.handleErrorAsync(
60
            error,
61
            request: request,
62
            response: response,
63
            completion: completion
64
          )
65

66
        case .success(let token):
67
          // Renewing worked! Add the token and move on
68
          self.addTokenAndProceed(
69
            token,
70
            to: request,
71
            chain: chain,
72
            response: response,
73
            completion: completion
74
          )
75
        }
76
      }
77
    } else {
78
      // We don't need to wait for renewal, add token and move on
79
      self.addTokenAndProceed(
80
        token,
81
        to: request,
82
        chain: chain,
83
        response: response,
84
        completion: completion
85
      )
86
    }
87
  }
88
}

1
import Foundation
2
import Apollo
3

4
class RequestLoggingInterceptor: ApolloInterceptor {
5

6
  public var id: String = UUID().uuidString
7

8
  func interceptAsync<Operation: GraphQLOperation>(
9
    chain: RequestChain,
10
    request: HTTPRequest<Operation>,
11
    response: HTTPResponse<Operation>?,
12
    completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
13
  ) {
14
    Logger.log(.debug, "Outgoing request: \(request)")
15
    chain.proceedAsync(
16
      request: request,
17
      response: response,
18
      interceptor: self,
19
      completion: completion
20
    )
21
  }
22
}

1
import Foundation
2
import Apollo
3

4
class ResponseLoggingInterceptor: ApolloInterceptor {
5

6
  enum ResponseLoggingError: Error {
7
    case notYetReceived
8
  }
9

10
  public var id: String = UUID().uuidString
11

12
  func interceptAsync<Operation: GraphQLOperation>(
13
    chain: RequestChain,
14
    request: HTTPRequest<Operation>,
15
    response: HTTPResponse<Operation>?,
16
    completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
17
  ) {
18
    defer {
19
      // Even if we can't log, we still want to keep going.
20
      chain.proceedAsync(
21
        request: request,
22
        response: response,
23
        interceptor: self,
24
        completion: completion
25
      )
26
    }
27

28
    guard let receivedResponse = response else {
29
      chain.handleErrorAsync(
30
        ResponseLoggingError.notYetReceived,
31
        request: request,
32
        response: response,
33
        completion: completion
34
      )
35
      return
36
    }
37

38
    Logger.log(.debug, "HTTP Response: \(receivedResponse.httpResponse)")
39

40
    if let stringData = String(bytes: receivedResponse.rawData, encoding: .utf8) {
41
      Logger.log(.debug, "Data: \(stringData)")
42
    } else {
43
      Logger.log(.error, "Could not convert data to string!")
44
    }
45
  }
46
}

1
import Foundation
2
import Apollo
3

4
class LoggingErrorInterceptor: ApolloErrorInterceptor {
5
  weak var errorLogger: MyErrorLogger?
6

7
  init(errorLogger: MyErrorLogger) {
8
    self.errorLogger = errorLogger
9
  }
10

11
  func handleErrorAsync<Operation: GraphQLOperation>(
12
    error: Error,
13
    chain: RequestChain,
14
    request: Apollo.HTTPRequest<Operation>,
15
    response: Apollo.HTTPResponse<Operation>?,
16
    completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
17
  ) {
18
    errorLogger?.requestFailed(response?.httpResponse, withError: error)
19
    completion(.failure(error))
20
  }
21
}

1
import Foundation
2
import Apollo
3

4
struct NetworkInterceptorProvider: InterceptorProvider {
5

6
  // These properties will remain the same throughout the life of the `InterceptorProvider`, even though they
7
  // will be handed to different interceptors.
8
  private let store: ApolloStore
9
  private let client: URLSessionClient
10

11
  init(store: ApolloStore, client: URLSessionClient) {
12
    self.store = store
13
    self.client = client
14
  }
15

16
  func interceptors<Operation: GraphQLOperation>(for operation: Operation) -> [ApolloInterceptor] {
17
    return [
18
      MaxRetryInterceptor(),
19
      CacheReadInterceptor(store: self.store),
20
      UserManagementInterceptor(),
21
      RequestLoggingInterceptor(),
22
      NetworkFetchInterceptor(client: self.client),
23
      ResponseLoggingInterceptor(),
24
      ResponseCodeInterceptor(),
25
      JSONResponseParsingInterceptor(),
26
      AutomaticPersistedQueryInterceptor(),
27
      CacheWriteInterceptor(store: self.store)
28
    ]
29
  }
30
}

1
import Foundation
2
import Apollo
3

4
let client: ApolloClient = {
5
  // The cache is necessary to set up the store, which we're going
6
  // to hand to the provider
7
  let cache = InMemoryNormalizedCache()
8
  let store = ApolloStore(cache: cache)
9

10
  let client = URLSessionClient()
11
  let provider = NetworkInterceptorProvider(store: store, client: client)
12
  let url = URL(string: "https://apollo-fullstack-tutorial.herokuapp.com/graphql")!
13

14
  let requestChainTransport = RequestChainNetworkTransport(
15
    interceptorProvider: provider,
16
    endpointURL: url
17
  )
18

19
  // Remember to give the store you already created to the client so it
20
  // doesn't create one on its own
21
  return ApolloClient(networkTransport: requestChainTransport, store: store)
22
}()