add ability to specify callback queue and have chain return value as funnel to callback queue

Author: designatednerd

Sources/Apollo/FinalizingInterceptor.swift

@@ -22,6 +22,7 @@ public class FinalizingInterceptor: ApolloInterceptor {
       return
     }
 
-    completion(.success(parsed))
+    chain.returnValueAsync(value: parsed,
+                           completion: completion)
   }
 }

Sources/Apollo/LegacyCacheReadInterceptor.swift

@@ -47,7 +47,8 @@ public class LegacyCacheReadInterceptor: ApolloInterceptor {
                                    response: response,
                                    completion: completion)
           case .success(let graphQLResult):
-            completion(.success(graphQLResult as! ParsedValue))
+            chain.returnValueAsync(value: graphQLResult as! ParsedValue,
+                                   completion: completion)
           }
 
           // In either case, keep going asynchronously
@@ -65,7 +66,8 @@ public class LegacyCacheReadInterceptor: ApolloInterceptor {
                                completion: completion)
           case .success(let graphQLResult):
             // Cache hit! We're done.
-            completion(.success(graphQLResult as! ParsedValue))
+            chain.returnValueAsync(value: graphQLResult as! ParsedValue,
+                                   completion: completion)
           }
         }
       case .returnCacheDataDontFetch:
@@ -78,7 +80,8 @@ public class LegacyCacheReadInterceptor: ApolloInterceptor {
                                    response: response,
                                    completion: completion)
           case .success(let result):
-            completion(.success(result as! ParsedValue))
+            chain.returnValueAsync(value: result as! ParsedValue,
+                                   completion: completion)
           }
         }
       }

Sources/Apollo/LegacyCacheWriteInterceptor.swift

@@ -58,7 +58,9 @@ public class LegacyCacheWriteInterceptor: ApolloInterceptor {
               preconditionFailure(String(describing: error))
           }
         }
-        completion(.success(result as! ParsedValue))
+        
+        chain.returnValueAsync(value: result as! ParsedValue,
+                               completion: completion)
       }.catch { error in
         chain.handleErrorAsync(error,
                                request: request,

Sources/Apollo/NetworkFetchInterceptor.swift

@@ -22,7 +22,10 @@ public class NetworkFetchInterceptor: ApolloInterceptor, Cancellable {
     do {
       urlRequest = try request.toURLRequest()
     } catch {
-      completion(.failure(error))
+      chain.handleErrorAsync(error,
+                             request: request,
+                             response: response,
+                             completion: completion)
       return
     }
 

Sources/Apollo/RequestChain.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if !COCOAPODS
+import ApolloCore
+#endif
 
 public class RequestChain: Cancellable {
 
@@ -9,21 +12,26 @@ public class RequestChain: Cancellable {
 
   private let interceptors: [ApolloInterceptor]
   private var currentIndex: Int
-  public private(set) var isCancelled: Bool = false
+  public private(set) var callbackQueue: DispatchQueue
+  public private(set) var isCancelled = Atomic<Bool>(false)
 
   /// Helper var for readability in guard statements
   public var isNotCancelled: Bool {
-    !self.isCancelled
+    !self.isCancelled.value
   }
 
   /// Something which allows additional error handling to occur when some kind of error has happened.
   public var additionalErrorHandler: ApolloErrorInterceptor?
 
   /// Creates a chain with the given interceptor array.
   ///
-  /// - Parameter interceptors: The interceptors to use.
-  public init(interceptors: [ApolloInterceptor]) {
+  /// - Parameters:
+  ///   - interceptors: The array of interceptors to use.
+  ///   - callbackQueue: The `DispatchQueue` to call back on when an error or result occurs. Defauls to `.main`.
+  public init(interceptors: [ApolloInterceptor],
+              callbackQueue: DispatchQueue = .main) {
     self.interceptors = interceptors
+    self.callbackQueue = callbackQueue
     self.currentIndex = 0
   }
 
@@ -86,7 +94,7 @@ public class RequestChain: Cancellable {
 
   /// Cancels the entire chain of interceptors.
   public func cancel() {
-    self.isCancelled = true
+    self.isCancelled.value = true
 
     // If an interceptor adheres to `Cancellable`, it should have its in-flight work cancelled as well.
     for interceptor in self.interceptors {
@@ -132,7 +140,9 @@ public class RequestChain: Cancellable {
     }
 
     guard let additionalHandler = self.additionalErrorHandler else {
-      completion(.failure(error))
+      self.callbackQueue.async {
+        completion(.failure(error))
+      }
       return
     }
 
@@ -143,4 +153,17 @@ public class RequestChain: Cancellable {
                                        response: response,
                                        completion: completion)
   }
+  
+  public func returnValueAsync<ParsedValue: Parseable>(
+    value: ParsedValue,
+    completion: @escaping (Result<ParsedValue, Error>) -> Void) {
+   
+    guard self.isNotCancelled else {
+      return
+    }
+    
+    self.callbackQueue.async {
+      completion(.success(value))
+    }
+  }
 }