Seperate transport functions by operation type

This allows for generic dispatch based on operation type to work properly.

Author: AnthonyMDev

apollo-ios/Sources/Apollo/ApolloClient.swift

@@ -5,6 +5,7 @@ import ApolloAPI
 #endif
 
 /// A cache policy that specifies whether results should be fetched from the server or loaded from the local cache.
+#warning("TODO: rethink this API. Onlye valid for queries currently")
 public enum CachePolicy: Sendable, Hashable {
   /// Return data from the cache if available, else fetch results from the server.
   case returnCacheDataElseFetch
@@ -39,11 +40,14 @@ public class ApolloClient: ApolloClientProtocol, @unchecked Sendable {
 
   public enum ApolloClientError: Error, LocalizedError, Hashable {
     case noUploadTransport
+    case noSubscriptionTransport
 
     public var errorDescription: String? {
       switch self {
       case .noUploadTransport:
         return "Attempting to upload using a transport which does not support uploads. This is a developer error."
+      case .noSubscriptionTransport:
+        return "Attempting to begin a subscription using a transport which does not support subscriptions. This is a developer error."
       }
     }
   }
@@ -103,8 +107,8 @@ public class ApolloClient: ApolloClientProtocol, @unchecked Sendable {
   ) -> (any Cancellable) {    
     return awaitStreamInTask(
       {
-        try await self.networkTransport.send(
-          operation: query,
+        try self.networkTransport.send(
+          query: query,
           cachePolicy: cachePolicy,
           contextIdentifier: contextIdentifier,
           context: context
@@ -185,7 +189,7 @@ public class ApolloClient: ApolloClientProtocol, @unchecked Sendable {
     return awaitStreamInTask(
       {
         try await self.networkTransport.send(
-          operation: mutation,
+          mutation: mutation,
           cachePolicy: publishResultToStore ? .default : .fetchIgnoringCacheCompletely,
           contextIdentifier: contextIdentifier,
           context: context
@@ -214,7 +218,7 @@ public class ApolloClient: ApolloClientProtocol, @unchecked Sendable {
 
     return awaitStreamInTask(
       {
-        try await uploadingTransport.upload(
+        try uploadingTransport.upload(
           operation: operation,
           files: files,
           context: context
@@ -231,10 +235,18 @@ public class ApolloClient: ApolloClientProtocol, @unchecked Sendable {
     queue: DispatchQueue = .main,
     resultHandler: @escaping GraphQLResultHandler<Subscription.Data>
   ) -> any Cancellable {
+    guard let networkTransport = networkTransport as? (any SubscriptionNetworkTransport) else {
+      assertionFailure("Trying to subscribe without a subscription transport. Please make sure your network transport conforms to `SubscriptionNetworkTransport`.")
+      queue.async {
+        resultHandler(.failure(ApolloClientError.noSubscriptionTransport))
+      }
+      return EmptyCancellable()
+    }
+
     return awaitStreamInTask(
       {
-        try await self.networkTransport.send(
-          operation: subscription,
+        try networkTransport.send(
+          subscription: subscription,
           cachePolicy: .default,
           contextIdentifier: nil,
           context: context)

apollo-ios/Sources/Apollo/Interceptors/JSONResponseParsingInterceptor.swift

@@ -24,10 +24,6 @@ public struct JSONResponseParsingInterceptor: ApolloInterceptor {
 
     let currentResult = CurrentResult<Request.Operation>()
 
-    if let request = request as? UploadRequest<Request.Operation> {
-
-    }
-
     return try await next(request).compactMap { result -> InterceptorResult<Request.Operation>? in
       let parser = JSONResponseParser<Request.Operation>(
         response: result.response,

apollo-ios/Sources/Apollo/NetworkTransport.swift

@@ -16,12 +16,32 @@ public protocol NetworkTransport: AnyObject, Sendable {
   ///   - contextIdentifier:  [optional] A unique identifier for this request, to help with deduping cache hits for watchers. Defaults to `nil`.
   ///   - context: [optional] A context that is being passed through the request chain. Defaults to `nil`.
   /// - Returns: A stream of `GraphQLResult`s for each response.
-  func send<Operation: GraphQLOperation>(
-    operation: Operation,
+  func send<Query: GraphQLQuery>(
+    query: Query,
     cachePolicy: CachePolicy,
     contextIdentifier: UUID?,
     context: (any RequestContext)?
-  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error>
+  ) throws -> AsyncThrowingStream<GraphQLResult<Query.Data>, any Error>
+
+  func send<Mutation: GraphQLMutation>(
+    mutation: Mutation,
+    cachePolicy: CachePolicy,
+    contextIdentifier: UUID?,
+    context: (any RequestContext)?
+  ) throws -> AsyncThrowingStream<GraphQLResult<Mutation.Data>, any Error>
+
+}
+
+// MARK: -
+
+public protocol SubscriptionNetworkTransport: NetworkTransport {
+
+  func send<Subscription: GraphQLSubscription>(
+    subscription: Subscription,
+    cachePolicy: CachePolicy,
+    contextIdentifier: UUID?,
+    context: (any RequestContext)?
+  ) throws -> AsyncThrowingStream<GraphQLResult<Subscription.Data>, any Error>
 
 }
 
@@ -37,9 +57,10 @@ public protocol UploadingNetworkTransport: NetworkTransport {
   ///   - files: An array of `GraphQLFile` objects to send.
   ///   - context: [optional] A context that is being passed through the request chain.
   /// - Returns: A stream of `GraphQLResult`s for each response.
+#warning("TODO: should support query and mutation as seperate functions")
   func upload<Operation: GraphQLOperation>(
     operation: Operation,
     files: [GraphQLFile],
     context: (any RequestContext)?
-  ) async throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error>
+  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error>
 }

apollo-ios/Sources/Apollo/RequestChain.swift

@@ -74,7 +74,7 @@ struct RequestChain<Request: GraphQLRequest>: Sendable {
       }
     }
   }
-
+  
   func kickoff(
     request: Request
   ) -> ResultStream {

apollo-ios/Sources/Apollo/RequestChainNetworkTransport.swift

@@ -1,6 +1,7 @@
 import Foundation
+
 #if !COCOAPODS
-import ApolloAPI
+  import ApolloAPI
 #endif
 
 /// An implementation of `NetworkTransport` which creates a `RequestChain` object
@@ -9,7 +10,7 @@ public final class RequestChainNetworkTransport: NetworkTransport, Sendable {
 
   /// The interceptor provider to use when constructing a request chain
   let interceptorProvider: any InterceptorProvider
-  
+
   /// The GraphQL endpoint URL to use.
   public let endpointURL: URL
 
@@ -74,7 +75,7 @@ public final class RequestChainNetworkTransport: NetworkTransport, Sendable {
     self.useGETForQueries = useGETForQueries
     self.sendEnhancedClientAwareness = sendEnhancedClientAwareness
   }
-  
+
   /// Constructs a GraphQL request for the given operation.
   ///
   /// Override this method if you need to use a custom subclass of `HTTPRequest`.
@@ -107,20 +108,39 @@ public final class RequestChainNetworkTransport: NetworkTransport, Sendable {
     request.addHeaders(self.additionalHeaders)
     return request
   }
-  
+
   // MARK: - NetworkTransport Conformance
 
-  public func send<Operation: GraphQLOperation>(
-    operation: Operation,
+  public func send<Query: GraphQLQuery>(
+    query: Query,
     cachePolicy: CachePolicy,
     contextIdentifier: UUID? = nil,
     context: (any RequestContext)? = nil
-  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
+  ) throws -> AsyncThrowingStream<GraphQLResult<Query.Data>, any Error> {
+    let request = self.constructRequest(
+      for: query,
+      cachePolicy: cachePolicy,
+      contextIdentifier: contextIdentifier,
+      context: context
+    )
+
+    let chain = makeChain(for: request)
+
+    return chain.kickoff(request: request)
+  }
+
+  public func send<Mutation: GraphQLMutation>(
+    mutation: Mutation,
+    cachePolicy: CachePolicy,
+    contextIdentifier: UUID? = nil,
+    context: (any RequestContext)? = nil
+  ) throws -> AsyncThrowingStream<GraphQLResult<Mutation.Data>, any Error> {
     let request = self.constructRequest(
-      for: operation,
+      for: mutation,
       cachePolicy: cachePolicy,
       contextIdentifier: contextIdentifier,
-      context: context)
+      context: context
+    )
 
     let chain = makeChain(for: request)
 
@@ -139,11 +159,11 @@ public final class RequestChainNetworkTransport: NetworkTransport, Sendable {
     )
     return chain
   }
-  
+
 }
 
 extension RequestChainNetworkTransport: UploadingNetworkTransport {
-  
+
   /// Constructs an uploading (ie, multipart) GraphQL request
   ///
   /// Override this method if you need to use a custom subclass of `HTTPRequest`.
@@ -152,7 +172,7 @@ extension RequestChainNetworkTransport: UploadingNetworkTransport {
   ///   - operation: The operation to create a request for
   ///   - files: The files you wish to upload
   ///   - context: [optional] A context that is being passed through the request chain. Should default to `nil`.
-  ///   - manualBoundary: [optional] A manually set boundary for your upload request. Defaults to nil. 
+  ///   - manualBoundary: [optional] A manually set boundary for your upload request. Defaults to nil.
   /// - Returns: The created request.
   public func constructUploadRequest<Operation: GraphQLOperation>(
     for operation: Operation,
@@ -174,12 +194,12 @@ extension RequestChainNetworkTransport: UploadingNetworkTransport {
     request.additionalHeaders = self.additionalHeaders
     return request
   }
-  
+
   public func upload<Operation: GraphQLOperation>(
     operation: Operation,
     files: [GraphQLFile],
     context: (any RequestContext)?
-  ) async throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
+  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
     let request = self.constructUploadRequest(for: operation, with: files, context: context)
     let chain = makeChain(for: request)
     return chain.kickoff(request: request)

apollo-ios/Sources/ApolloWebSocket/SplitNetworkTransport.swift

@@ -1,17 +1,20 @@
 import Foundation
+
 #if !COCOAPODS
-import Apollo
-import ApolloAPI
+  import Apollo
+  import ApolloAPI
 #endif
 
-#warning("""
-TODO: This is messy. Why is http network transport called "uploadingNetworkTransport"?
-Websocket transport should be typesafe to a protocol that guaruntees it supports web sockets/ subscriptions
-""")
+#warning(
+  """
+  TODO: This is messy. Why is http network transport called "uploadingNetworkTransport"?
+  Websocket transport should be typesafe to a protocol that guaruntees it supports web sockets/ subscriptions
+  """
+)
 /// A network transport that sends subscriptions using one `NetworkTransport` and other requests using another `NetworkTransport`. Ideal for sending subscriptions via a web socket but everything else via HTTP.
 public final class SplitNetworkTransport: Sendable {
   private let uploadingNetworkTransport: any UploadingNetworkTransport
-  private let webSocketNetworkTransport: any NetworkTransport
+  private let webSocketNetworkTransport: any SubscriptionNetworkTransport
 
   public var clientName: String {
     let httpName = self.uploadingNetworkTransport.clientName
@@ -32,13 +35,16 @@ public final class SplitNetworkTransport: Sendable {
       return "SPLIT_HTTPVERSION_\(httpVersion)_WEBSOCKETVERSION_\(websocketVersion)"
     }
   }
-  
+
   /// Designated initializer
   ///
   /// - Parameters:
   ///   - uploadingNetworkTransport: An `UploadingNetworkTransport` to use for non-subscription requests. Should generally be a `RequestChainNetworkTransport` or something similar.
   ///   - webSocketNetworkTransport: A `NetworkTransport` to use for subscription requests. Should generally be a `WebSocketTransport` or something similar.
-  public init(uploadingNetworkTransport: any UploadingNetworkTransport, webSocketNetworkTransport: any NetworkTransport) {
+  public init(
+    uploadingNetworkTransport: any UploadingNetworkTransport,
+    webSocketNetworkTransport: any SubscriptionNetworkTransport
+  ) {
     self.uploadingNetworkTransport = uploadingNetworkTransport
     self.webSocketNetworkTransport = webSocketNetworkTransport
   }
@@ -48,25 +54,50 @@ public final class SplitNetworkTransport: Sendable {
 
 extension SplitNetworkTransport: NetworkTransport {
 
-  public func send<Operation: GraphQLOperation>(
-    operation: Operation,
+  public func send<Query>(
+    query: Query,
     cachePolicy: CachePolicy,
-    contextIdentifier: UUID? = nil,
-    context: (any RequestContext)? = nil
-  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
-    if Operation.operationType == .subscription {
-      return try webSocketNetworkTransport.send(
-        operation: operation,
-        cachePolicy: cachePolicy,
-        contextIdentifier: contextIdentifier,
-        context: context)
-    } else {
-      return try uploadingNetworkTransport.send(
-        operation: operation,
-        cachePolicy: cachePolicy,
-        contextIdentifier: contextIdentifier,
-        context: context)
-    }
+    contextIdentifier: UUID?,
+    context: (any RequestContext)?
+  ) throws -> AsyncThrowingStream<GraphQLResult<Query.Data>, any Error> where Query: GraphQLQuery {
+    return try uploadingNetworkTransport.send(
+      query: query,
+      cachePolicy: cachePolicy,
+      contextIdentifier: contextIdentifier,
+      context: context
+    )
+  }
+
+  public func send<Mutation>(
+    mutation: Mutation,
+    cachePolicy: CachePolicy,
+    contextIdentifier: UUID?,
+    context: (any RequestContext)?
+  ) throws -> AsyncThrowingStream<GraphQLResult<Mutation.Data>, any Error> where Mutation: GraphQLMutation {
+    return try uploadingNetworkTransport.send(
+      mutation: mutation,
+      cachePolicy: cachePolicy,
+      contextIdentifier: contextIdentifier,
+      context: context
+    )
+  }
+}
+
+// MARK: - SubscriptionNetworkTransport conformance
+
+extension SplitNetworkTransport: SubscriptionNetworkTransport {
+  public func send<Subscription>(
+    subscription: Subscription,
+    cachePolicy: CachePolicy,
+    contextIdentifier: UUID?,
+    context: (any RequestContext)?
+  ) throws -> AsyncThrowingStream<GraphQLResult<Subscription.Data>, any Error> where Subscription: GraphQLSubscription {
+    return try webSocketNetworkTransport.send(
+      subscription: subscription,
+      cachePolicy: cachePolicy,
+      contextIdentifier: contextIdentifier,
+      context: context
+    )
   }
 }
 
@@ -78,8 +109,8 @@ extension SplitNetworkTransport: UploadingNetworkTransport {
     operation: Operation,
     files: [GraphQLFile],
     context: (any RequestContext)?
-  ) async throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
-    return try await uploadingNetworkTransport.upload(
+  ) throws -> AsyncThrowingStream<GraphQLResult<Operation.Data>, any Error> {
+    return try uploadingNetworkTransport.upload(
       operation: operation,
       files: files,
       context: context