Create FetchOptions to allow GET Requests like in Web

Apollo.xcodeproj/project.pbxproj

@@ -8,6 +8,7 @@
 
 /* Begin PBXBuildFile section */
 		54DDB0921EA045870009DD99 /* InMemoryNormalizedCache.swift in Sources */ = {isa = PBXBuildFile; fileRef = 54DDB0911EA045870009DD99 /* InMemoryNormalizedCache.swift */; };
+		5AC6CA4322AAF7B200B7C94D /* FetchOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5AC6CA4222AAF7B200B7C94D /* FetchOptions.swift */; };
 		9F0CA4451EE7F9E90032DD39 /* ApolloTestSupport.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9F8A95781EC0FC1200304A2D /* ApolloTestSupport.framework */; };
 		9F0CA4461EE7F9E90032DD39 /* ApolloTestSupport.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 9F8A95781EC0FC1200304A2D /* ApolloTestSupport.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
 		9F10A51E1EC1BA0F0045E62B /* MockNetworkTransport.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9F10A51D1EC1BA0F0045E62B /* MockNetworkTransport.swift */; };
@@ -230,6 +231,7 @@
 
 /* Begin PBXFileReference section */
 		54DDB0911EA045870009DD99 /* InMemoryNormalizedCache.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = InMemoryNormalizedCache.swift; sourceTree = "<group>"; };
+		5AC6CA4222AAF7B200B7C94D /* FetchOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FetchOptions.swift; sourceTree = "<group>"; };
 		90690D05224333DA00FC2E54 /* Apollo-Project-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Apollo-Project-Debug.xcconfig"; sourceTree = "<group>"; };
 		90690D06224333DA00FC2E54 /* Apollo-Target-Framework.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Apollo-Target-Framework.xcconfig"; sourceTree = "<group>"; };
 		90690D07224333DA00FC2E54 /* Apollo-Project-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Apollo-Project-Release.xcconfig"; sourceTree = "<group>"; };
@@ -535,6 +537,7 @@
 			isa = PBXGroup;
 			children = (
 				9FC750621D2A59F600458D91 /* ApolloClient.swift */,
+				5AC6CA4222AAF7B200B7C94D /* FetchOptions.swift */,
 				9FC750601D2A59C300458D91 /* GraphQLOperation.swift */,
 				9FC9A9BE1E2C27FB0023C4D5 /* GraphQLResult.swift */,
 				9FC9A9D21E2FD48B0023C4D5 /* GraphQLError.swift */,
@@ -1083,6 +1086,7 @@
 				9FA6F3681E65DF4700BF8D73 /* GraphQLResultAccumulator.swift in Sources */,
 				9FF90A651DDDEB100034C3B6 /* GraphQLExecutor.swift in Sources */,
 				9FC750611D2A59C300458D91 /* GraphQLOperation.swift in Sources */,
+				5AC6CA4322AAF7B200B7C94D /* FetchOptions.swift in Sources */,
 				9FE941D01E62C771007CDD89 /* Promise.swift in Sources */,
 				9FC750631D2A59F600458D91 /* ApolloClient.swift in Sources */,
 				9F86B6901E65533D00B885FF /* GraphQLResponseGenerator.swift in Sources */,

Sources/Apollo/ApolloClient.swift

@@ -76,21 +76,22 @@ public class ApolloClient {
   ///
   /// - Parameters:
   ///   - query: The query to fetch.
+  ///   - fetchOptions: The HTTP Method to be used. Default is POST.
   ///   - cachePolicy: A cache policy that specifies when results should be fetched from the server and when data should be loaded from the local cache.
   ///   - queue: A dispatch queue on which the result handler will be called. Defaults to the main queue.
   ///   - resultHandler: An optional closure that is called when query results are available or when an error occurs.
   /// - Returns: An object that can be used to cancel an in progress fetch.
-  @discardableResult public func fetch<Query: GraphQLQuery>(query: Query, cachePolicy: CachePolicy = .returnCacheDataElseFetch, queue: DispatchQueue = DispatchQueue.main, resultHandler: OperationResultHandler<Query>? = nil) -> Cancellable {
-    return _fetch(query: query, cachePolicy: cachePolicy, queue: queue, resultHandler: resultHandler)
+  @discardableResult public func fetch<Query: GraphQLQuery>(query: Query, fetchOptions: FetchOptions = .POST, cachePolicy: CachePolicy = .returnCacheDataElseFetch, queue: DispatchQueue = DispatchQueue.main, resultHandler: OperationResultHandler<Query>? = nil) -> Cancellable {
+    return _fetch(query: query, fetchOptions: fetchOptions, cachePolicy: cachePolicy, queue: queue, resultHandler: resultHandler)
   }
 
-  func _fetch<Query: GraphQLQuery>(query: Query, cachePolicy: CachePolicy, context: UnsafeMutableRawPointer? = nil, queue: DispatchQueue, resultHandler: OperationResultHandler<Query>?) -> Cancellable {
+  func _fetch<Query: GraphQLQuery>(query: Query, fetchOptions: FetchOptions, cachePolicy: CachePolicy, context: UnsafeMutableRawPointer? = nil, queue: DispatchQueue, resultHandler: OperationResultHandler<Query>?) -> Cancellable {
     // If we don't have to go through the cache, there is no need to create an operation 
     // and we can return a network task directly
     if cachePolicy == .fetchIgnoringCacheData {
-      return send(operation: query, context: context, handlerQueue: queue, resultHandler: resultHandler)
+      return send(operation: query, fetchOptions: fetchOptions, context: context, handlerQueue: queue, resultHandler: resultHandler)
     } else {
-      let operation = FetchQueryOperation(client: self, query: query, cachePolicy: cachePolicy, context: context, handlerQueue: queue, resultHandler: resultHandler)
+      let operation = FetchQueryOperation(client: self, query: query, fetchOptions: fetchOptions, cachePolicy: cachePolicy, context: context, handlerQueue: queue, resultHandler: resultHandler)
       operationQueue.addOperation(operation)
       return operation
     }
@@ -100,12 +101,13 @@ public class ApolloClient {
   ///
   /// - Parameters:
   ///   - query: The query to fetch.
+  ///   - fetchOptions: The HTTP Method to be used. Default is POST.
   ///   - cachePolicy: A cache policy that specifies when results should be fetched from the server or from the local cache.
   ///   - queue: A dispatch queue on which the result handler will be called. Defaults to the main queue.
   ///   - resultHandler: An optional closure that is called when query results are available or when an error occurs.
   /// - Returns: A query watcher object that can be used to control the watching behavior.
-  public func watch<Query: GraphQLQuery>(query: Query, cachePolicy: CachePolicy = .returnCacheDataElseFetch, queue: DispatchQueue = DispatchQueue.main, resultHandler: @escaping OperationResultHandler<Query>) -> GraphQLQueryWatcher<Query> {
-    let watcher = GraphQLQueryWatcher(client: self, query: query, handlerQueue: queue, resultHandler: resultHandler)
+  public func watch<Query: GraphQLQuery>(query: Query, fetchOptions: FetchOptions = .POST, cachePolicy: CachePolicy = .returnCacheDataElseFetch, queue: DispatchQueue = DispatchQueue.main, resultHandler: @escaping OperationResultHandler<Query>) -> GraphQLQueryWatcher<Query> {
+    let watcher = GraphQLQueryWatcher(client: self, query: query, fetchOptions: fetchOptions, handlerQueue: queue, resultHandler: resultHandler)
     watcher.fetch(cachePolicy: cachePolicy)
     return watcher
   }
@@ -114,30 +116,32 @@ public class ApolloClient {
   ///
   /// - Parameters:
   ///   - mutation: The mutation to perform.
+  ///   - fetchOptions: The HTTP Method to be used. Default is POST.
   ///   - queue: A dispatch queue on which the result handler will be called. Defaults to the main queue.
   ///   - resultHandler: An optional closure that is called when mutation results are available or when an error occurs.
   /// - Returns: An object that can be used to cancel an in progress mutation.
-  @discardableResult public func perform<Mutation: GraphQLMutation>(mutation: Mutation, queue: DispatchQueue = DispatchQueue.main, resultHandler: OperationResultHandler<Mutation>? = nil) -> Cancellable {
-    return _perform(mutation: mutation, queue: queue, resultHandler: resultHandler)
+  @discardableResult public func perform<Mutation: GraphQLMutation>(mutation: Mutation, fetchOptions: FetchOptions = .POST, queue: DispatchQueue = DispatchQueue.main, resultHandler: OperationResultHandler<Mutation>? = nil) -> Cancellable {
+        return _perform(mutation: mutation, fetchOptions: fetchOptions, queue: queue, resultHandler: resultHandler)
   }
 
-  func _perform<Mutation: GraphQLMutation>(mutation: Mutation, context: UnsafeMutableRawPointer? = nil, queue: DispatchQueue, resultHandler: OperationResultHandler<Mutation>?) -> Cancellable {
-    return send(operation: mutation, context: context, handlerQueue: queue, resultHandler: resultHandler)
+  func _perform<Mutation: GraphQLMutation>(mutation: Mutation, fetchOptions: FetchOptions, context: UnsafeMutableRawPointer? = nil, queue: DispatchQueue, resultHandler: OperationResultHandler<Mutation>?) -> Cancellable {
+    return send(operation: mutation, fetchOptions: fetchOptions, context: context, handlerQueue: queue, resultHandler: resultHandler)
   }
 
   /// Subscribe to a subscription
   ///
   /// - Parameters:
   ///   - subscription: The subscription to subscribe to.
+  ///   - fetchOptions: The HTTP Method to be used. Default is POST.
   ///   - queue: A dispatch queue on which the result handler will be called. Defaults to the main queue.
   ///   - resultHandler: An optional closure that is called when mutation results are available or when an error occurs.
   /// - Returns: An object that can be used to cancel an in progress subscription.
-  @discardableResult public func subscribe<Subscription: GraphQLSubscription>(subscription: Subscription, queue: DispatchQueue = DispatchQueue.main, resultHandler: @escaping OperationResultHandler<Subscription>) -> Cancellable {
-    return send(operation: subscription, context: nil, handlerQueue: queue, resultHandler: resultHandler)
+  @discardableResult public func subscribe<Subscription: GraphQLSubscription>(subscription: Subscription, fetchOptions: FetchOptions = .POST, queue: DispatchQueue = DispatchQueue.main, resultHandler: @escaping OperationResultHandler<Subscription>) -> Cancellable {
+    return send(operation: subscription, fetchOptions: fetchOptions, context: nil, handlerQueue: queue, resultHandler: resultHandler)
   }
 
 
-  fileprivate func send<Operation: GraphQLOperation>(operation: Operation, context: UnsafeMutableRawPointer?, handlerQueue: DispatchQueue, resultHandler: OperationResultHandler<Operation>?) -> Cancellable {
+  fileprivate func send<Operation: GraphQLOperation>(operation: Operation, fetchOptions: FetchOptions, context: UnsafeMutableRawPointer?, handlerQueue: DispatchQueue, resultHandler: OperationResultHandler<Operation>?) -> Cancellable {
     func notifyResultHandler(result: GraphQLResult<Operation.Data>?, error: Error?) {
       guard let resultHandler = resultHandler else { return }
 
@@ -146,7 +150,7 @@ public class ApolloClient {
       }
     }
 
-    return networkTransport.send(operation: operation) { (response, error) in
+    return networkTransport.send(operation: operation, fetchOptions: fetchOptions) { (response, error) in
       guard let response = response else {
         notifyResultHandler(result: nil, error: error)
         return
@@ -175,16 +179,18 @@ public class ApolloClient {
 private final class FetchQueryOperation<Query: GraphQLQuery>: AsynchronousOperation, Cancellable {
   let client: ApolloClient
   let query: Query
+  let fetchOptions: FetchOptions
   let cachePolicy: CachePolicy
   let context: UnsafeMutableRawPointer?
   let handlerQueue: DispatchQueue
   let resultHandler: OperationResultHandler<Query>?
 
   private var networkTask: Cancellable?
 
-  init(client: ApolloClient, query: Query, cachePolicy: CachePolicy, context: UnsafeMutableRawPointer?, handlerQueue: DispatchQueue, resultHandler: OperationResultHandler<Query>?) {
+  init(client: ApolloClient, query: Query, fetchOptions: FetchOptions, cachePolicy: CachePolicy, context: UnsafeMutableRawPointer?, handlerQueue: DispatchQueue, resultHandler: OperationResultHandler<Query>?) {
     self.client = client
     self.query = query
+    self.fetchOptions = fetchOptions
     self.cachePolicy = cachePolicy
     self.context = context
     self.handlerQueue = handlerQueue
@@ -230,7 +236,7 @@ private final class FetchQueryOperation<Query: GraphQLQuery>: AsynchronousOperat
   }
 
   func fetchFromNetwork() {
-    networkTask = client.send(operation: query, context: context, handlerQueue: handlerQueue) { (result, error) in
+    networkTask = client.send(operation: query, fetchOptions: fetchOptions, context: context, handlerQueue: handlerQueue) { (result, error) in
       self.notifyResultHandler(result: result, error: error)
       self.state = .finished
       return

Sources/Apollo/FetchOptions.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public enum FetchOptions: String {
+    case GET
+    case POST
+}

Sources/Apollo/GraphQLQueryWatcher.swift

@@ -4,6 +4,7 @@ import Dispatch
 public final class GraphQLQueryWatcher<Query: GraphQLQuery>: Cancellable, ApolloStoreSubscriber {
   weak var client: ApolloClient?
   let query: Query
+  let fetchOptions: FetchOptions
   let handlerQueue: DispatchQueue
   let resultHandler: OperationResultHandler<Query>
 
@@ -13,9 +14,10 @@ public final class GraphQLQueryWatcher<Query: GraphQLQuery>: Cancellable, Apollo
 
   private var dependentKeys: Set<CacheKey>?
 
-  init(client: ApolloClient, query: Query, handlerQueue: DispatchQueue, resultHandler: @escaping OperationResultHandler<Query>) {
+  init(client: ApolloClient, query: Query, fetchOptions: FetchOptions, handlerQueue: DispatchQueue, resultHandler: @escaping OperationResultHandler<Query>) {
     self.client = client
     self.query = query
+    self.fetchOptions = fetchOptions
     self.handlerQueue = handlerQueue
     self.resultHandler = resultHandler
 
@@ -28,7 +30,7 @@ public final class GraphQLQueryWatcher<Query: GraphQLQuery>: Cancellable, Apollo
   }
 
   func fetch(cachePolicy: CachePolicy) {
-    fetching = client?._fetch(query: query, cachePolicy: cachePolicy, context: &context, queue: handlerQueue) { [weak self] (result, error) in
+    fetching = client?._fetch(query: query, fetchOptions: fetchOptions, cachePolicy: cachePolicy, context: &context, queue: handlerQueue) { [weak self] (result, error) in
       guard let `self` = self else { return }
 
       self.dependentKeys = result?.dependentKeys

Sources/Apollo/HTTPNetworkTransport.swift

@@ -69,18 +69,23 @@ public class HTTPNetworkTransport: NetworkTransport {
   ///
   /// - Parameters:
   ///   - operation: The operation to send.
+  ///   - fetchOptions: The HTTP Method to be used.
   ///   - completionHandler: A closure to call when a request completes.
   ///   - response: The response received from the server, or `nil` if an error occurred.
   ///   - error: An error that indicates why a request failed, or `nil` if the request was succesful.
   /// - Returns: An object that can be used to cancel an in progress request.
-  public func send<Operation>(operation: Operation, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable {
+  public func send<Operation>(operation: Operation, fetchOptions: FetchOptions, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable {
+    let body = requestBody(for: operation)
     var request = URLRequest(url: url)
-    request.httpMethod = "POST"
 
+    if fetchOptions.rawValue == "GET", let urlForGet = mountUrlWithQueryParamsIfNeeded(body: body) {
+        request = URLRequest(url: urlForGet)
+    } else if fetchOptions.rawValue == "POST" {
+        request.httpBody = try! serializationFormat.serialize(value: body)
+    }
+
+    request.httpMethod = fetchOptions.rawValue
     request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-
-    let body = requestBody(for: operation)
-    request.httpBody = try! serializationFormat.serialize(value: body)
 
     let task = session.dataTask(with: request) { (data: Data?, response: URLResponse?, error: Error?) in
       if error != nil {
@@ -129,4 +134,46 @@ public class HTTPNetworkTransport: NetworkTransport {
     }
     return ["query": operation.queryDocument, "variables": operation.variables]
   }
+
+  private func mountUrlWithQueryParamsIfNeeded(body: GraphQLMap) -> URL? {
+    guard let query = body.jsonObject["query"], var queryParam = queryString(withItems:  [URLQueryItem(name: "query", value: "\(query)")]) else {
+        return self.url
+    }
+    if areThereVariables(in: body) {
+        guard let serializedVariables = try? serializationFormat.serialize(value: body.jsonObject["variables"]) else {
+            return URL(string: "\(self.url.absoluteString)?\(queryParam)")
+        }
+        queryParam += getVariablesEncodedString(of: serializedVariables)
+    }
+    guard let urlForGet = URL(string: "\(self.url.absoluteString)?\(queryParam)") else {
+        return URL(string: "\(self.url.absoluteString)?\(queryParam)")
+    }
+    return urlForGet
+  }
+
+  private func areThereVariables(in map: GraphQLMap) -> Bool {
+    if let variables = map.jsonObject["variables"], "\(variables)" != "<null>" {
+        return true
+    }
+    return false
+  }
+
+  private func getVariablesEncodedString(of data: Data) -> String {
+    var dataString = String(data: data, encoding: String.Encoding.utf8) ?? ""
+    dataString = dataString.replacingOccurrences(of: ";", with: ",")
+    dataString = dataString.replacingOccurrences(of: "=", with: ":")
+    guard let variablesEncoded = queryString(withItems:  [URLQueryItem(name: "variables", value: "\(dataString)")]) else { return "" }
+    return "&\(variablesEncoded)"
+  }
+
+  private func queryString(withItems items: [URLQueryItem], percentEncoded: Bool = true) -> String? {
+    let url = NSURLComponents()
+    url.queryItems = items
+    let queryString = percentEncoded ? url.percentEncodedQuery : url.query
+
+    if let queryString = queryString {
+        return "\(queryString)"
+    }
+    return nil
+  }
 }

Sources/Apollo/NetworkTransport.swift

@@ -4,10 +4,11 @@ public protocol NetworkTransport {
   ///
   /// - Parameters:
   ///   - operation: The operation to send.
+  ///   - fetchOptions: The HTTP Method to be used.
   ///   - completionHandler: A closure to call when a request completes.
   ///   - response: The response received from the server, or `nil` if an error occurred.
   ///   - error: An error that indicates why a request failed, or `nil` if the request was succesful.
   /// - Returns: An object that can be used to cancel an in progress request.
-  func send<Operation>(operation: Operation, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable
+  func send<Operation>(operation: Operation, fetchOptions: FetchOptions, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable
 }
 

Sources/ApolloWebSocket/SplitNetworkTransport.swift

@@ -9,11 +9,11 @@ public class SplitNetworkTransport: NetworkTransport {
     self.webSocketNetworkTransport = webSocketNetworkTransport
   }
 
-  public func send<Operation>(operation: Operation, completionHandler: @escaping (GraphQLResponse<Operation>?, Error?) -> Void) -> Cancellable {
+  public func send<Operation>(operation: Operation, fetchOptions: FetchOptions, completionHandler: @escaping (GraphQLResponse<Operation>?, Error?) -> Void) -> Cancellable {
     if operation.operationType == .subscription {
-        return webSocketNetworkTransport.send(operation: operation, completionHandler: completionHandler)
+        return webSocketNetworkTransport.send(operation: operation, fetchOptions: fetchOptions, completionHandler: completionHandler)
     } else {
-        return httpNetworkTransport.send(operation: operation, completionHandler: completionHandler)
+        return httpNetworkTransport.send(operation: operation, fetchOptions: fetchOptions, completionHandler: completionHandler)
     }
   }
 }

Sources/ApolloWebSocket/WebSocketTransport.swift

@@ -59,7 +59,7 @@ public class WebSocketTransport: NetworkTransport, WebSocketDelegate {
     self.websocket.connect()
   }
 
-  public func send<Operation>(operation: Operation, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable {
+  public func send<Operation>(operation: Operation, fetchOptions: FetchOptions, completionHandler: @escaping (_ response: GraphQLResponse<Operation>?, _ error: Error?) -> Void) -> Cancellable {
     if let error = self.error {
       completionHandler(nil,error)
     }