[v2] [8/X] Add OperationResponseFormat

Tests/ApolloInternalTestHelpers/MockNetworkTransport.swift

@@ -19,24 +19,20 @@ public final class MockNetworkTransport: NetworkTransport {
   public func send<Query>(
     query: Query,
     cachePolicy: CachePolicy,
-    context: (any RequestContext)?
   ) throws -> AsyncThrowingStream<GraphQLResult<Query.Data>, any Error> where Query: GraphQLQuery {
     try requestChainTransport.send(
       query: query,
-      cachePolicy: cachePolicy,
-      context: context
+      cachePolicy: cachePolicy
     )
   }
 
   public func send<Mutation>(
     mutation: Mutation,
     cachePolicy: CachePolicy,
-    context: (any RequestContext)?
   ) throws -> AsyncThrowingStream<GraphQLResult<Mutation.Data>, any Error> where Mutation: GraphQLMutation {
     try requestChainTransport.send(
       mutation: mutation,
-      cachePolicy: cachePolicy,
-      context: context
+      cachePolicy: cachePolicy
     )
   }
 

Tests/ApolloInternalTestHelpers/MockOperation.swift

@@ -15,9 +15,6 @@ open class MockOperation<SelectionSet: RootSelectionSet>: GraphQLOperation, @unc
   open var __variables: Variables?
 
   public init() {}
-
-  open class var deferredFragments: [DeferredFragmentIdentifier : any ApolloAPI.SelectionSet.Type]? { return nil }
-
 }
 
 open class MockQuery<SelectionSet: RootSelectionSet>: MockOperation<SelectionSet>, GraphQLQuery, @unchecked Sendable {

Tests/ApolloTests/Cache/CacheDependentInterceptorTests.swift

@@ -55,22 +55,31 @@ class CacheDependentInterceptorTests: XCTestCase, CacheDependentTesting, MockRes
     ])
 
     /// This interceptor will reroute anything that fails with a response code error to retry hitting only the cache
-    final class RerouteToCacheErrorInterceptor: ApolloErrorInterceptor {
+    final class RerouteToCacheErrorInterceptor: ApolloInterceptor {
       nonisolated(unsafe) var handledError: (any Error)?
 
-      func intercept<Request>(
-        error: any Error,
+      func intercept<Request: GraphQLRequest>(
         request: Request,
-        result: InterceptorResult<Request.Operation>?
-      ) async throws -> GraphQLResult<Request.Operation.Data> where Request: GraphQLRequest {
-        self.handledError = error
-
-        guard error is ResponseCodeInterceptor.ResponseCodeError else {
-          throw error
+        next: NextInterceptorFunction<Request>
+      ) async throws -> InterceptorResultStream<GraphQLResponse<Request.Operation>> {
+
+        do {
+          return try await next(request)
+
+        } catch {
+          self.handledError = error
+          guard error is ResponseCodeInterceptor.ResponseCodeError else {
+            throw error
+          }
+          var request = request
+          request.fetchBehavior = FetchBehavior(
+            shouldAttemptCacheRead: true,
+            shouldAttemptCacheWrite: true,
+            shouldAttemptNetworkFetch: .never
+          )
+
+          throw RequestChain.Retry(request: request)
         }
-        var request = request
-        request.cachePolicy = .returnCacheDataDontFetch
-        throw RequestChainRetry(request: request)
       }
     }
 
@@ -86,13 +95,8 @@ class CacheDependentInterceptorTests: XCTestCase, CacheDependentTesting, MockRes
 
       func interceptors<Operation>(for operation: Operation) -> [any ApolloInterceptor]
       where Operation: GraphQLOperation {
-        []
-      }
-
-      func errorInterceptor<Operation>(for operation: Operation) -> (any ApolloErrorInterceptor)?
-      where Operation: GraphQLOperation {
-        self.errorInterceptor
-      }
+        [self.errorInterceptor]
+      }      
     }
 
     await CacheDependentInterceptorTests.registerRequestHandler(for: TestURL.mockServer.url) { _ in

Tests/ApolloTests/DeferTests.swift

@@ -42,7 +42,22 @@ final class DeferTests: XCTestCase, MockResponseProvider {
     }
   }
 
-  private final class TVShowQuery: MockQuery<TVShowQuery.Data>, @unchecked Sendable {
+  private struct TVShowQuery: GraphQLQuery, @unchecked Sendable {
+    static var operationName: String { "TVShowQuery" }
+
+    static var operationDocument: OperationDocument {
+      .init(definition: .init("Mock Operation Definition"))
+    }
+
+    static var responseFormat: IncrementalDeferredResponseFormat {
+      IncrementalDeferredResponseFormat(deferredFragments: [
+        .init(label: "deferredGenres", fieldPath: ["show"]): Data.Show.DeferredGenres.self,
+        .init(label: "deferredFriend", fieldPath: ["show", "characters"]): Data.Show.Character.DeferredFriend.self,
+      ])
+    }
+
+    public var __variables: Variables?
+
     final class Data: MockSelectionSet, @unchecked Sendable {
       override class var __selections: [Selection] {
         [
@@ -118,14 +133,6 @@ final class DeferTests: XCTestCase, MockResponseProvider {
         }
       }
     }
-
-    override class var deferredFragments: [DeferredFragmentIdentifier: any SelectionSet.Type]? {
-      [
-        DeferredFragmentIdentifier(label: "deferredGenres", fieldPath: ["show"]): Data.Show.DeferredGenres.self,
-        DeferredFragmentIdentifier(label: "deferredFriend", fieldPath: ["show", "characters"]): Data.Show.Character
-          .DeferredFriend.self,
-      ]
-    }
   }
 
   let defaultTimeout = 0.5
@@ -185,7 +192,7 @@ final class DeferTests: XCTestCase, MockResponseProvider {
 
     let response = results.first
     let data = response?.data
-    
+
     expect(data?.__data._fulfilledFragments).to(
       equal([
         ObjectIdentifier(TVShowQuery.Data.self)

Tests/ApolloTests/IncrementalGraphQLResponseTests.swift

@@ -6,13 +6,24 @@ import Nimble
 
 final class IncrementalGraphQLResponseTests: XCTestCase {
 
-  class DeferredQuery: MockQuery<DeferredQuery.Data> {
-    class Data: MockSelectionSet {
+  class DeferredQuery: GraphQLQuery, @unchecked Sendable {
+    static var operationName: String { "DeferredQuery" }
+
+    static var operationDocument: ApolloAPI.OperationDocument { .init(definition: .init("Mock Operation Definition")) }
+
+    static var responseFormat: IncrementalDeferredResponseFormat {
+      IncrementalDeferredResponseFormat(deferredFragments: [
+        DeferredFragmentIdentifier(label: "deferredFriend", fieldPath: ["animal"]): Data.Animal.DeferredFriend.self,
+        // Data.Animal.DeliberatelyMissing is intentionally not here for error testing
+      ])
+    }
+
+    class Data: MockSelectionSet, @unchecked Sendable {
       override class var __selections: [Selection] {[
         .field("animal", Animal.self),
       ]}
 
-      class Animal: AbstractMockSelectionSet<Animal.Fragments, MockSchemaMetadata> {
+      class Animal: AbstractMockSelectionSet<Animal.Fragments, MockSchemaMetadata>, @unchecked Sendable {
         override class var __selections: [Selection] {[
           .field("__typename", String.self),
           .field("name", String.self),
@@ -33,24 +44,19 @@ final class IncrementalGraphQLResponseTests: XCTestCase {
           @Deferred var deliberatelyMissing: DeliberatelyMissing?
         }
 
-        class DeferredFriend: MockTypeCase {
+        class DeferredFriend: MockTypeCase, @unchecked Sendable {
           override class var __selections: [Selection] {[
             .field("friend", String.self),
           ]}
         }
 
-        class DeliberatelyMissing: MockTypeCase {
+        class DeliberatelyMissing: MockTypeCase, @unchecked Sendable {
           override class var __selections: [Selection] {[
             .field("key", String.self),
           ]}
         }
       }
     }
-
-    override class var deferredFragments: [DeferredFragmentIdentifier : any SelectionSet.Type]? {[
-      DeferredFragmentIdentifier(label: "deferredFriend", fieldPath: ["animal"]): Data.Animal.DeferredFriend.self,
-      // Data.Animal.DeliberatelyMissing is intentionally not here for error testing
-    ]}
   }
 
   // MARK: - Initialization Tests

Tests/ApolloTests/Interceptors/JSONResponseParsingInterceptorTests_IncrementalItems.swift

@@ -431,7 +431,21 @@ final class JSONResponseParsingInterceptorTests_IncrementalItems: XCTestCase {
     }
   }
 
-  final class AnimalQuery: MockQuery<AnimalQuery.AnAnimal>, @unchecked Sendable {
+  struct AnimalQuery: GraphQLQuery, @unchecked Sendable {
+    static var operationName: String { "AnimalQuery" }
+
+    static var operationDocument: OperationDocument {
+      .init(definition: .init("Mock Operation Definition"))
+    }
+
+    static var responseFormat: IncrementalDeferredResponseFormat {
+      IncrementalDeferredResponseFormat(deferredFragments: [
+        DeferredFragmentIdentifier(label: "deferredGenus", fieldPath: ["animal"]): AnAnimal.Animal.DeferredGenus.self,
+        DeferredFragmentIdentifier(label: "deferredFriend", fieldPath: ["animal"]): AnAnimal.Animal.DeferredFriend.self,
+      ])
+    }
+
+    typealias Data = AnAnimal
     final class AnAnimal: MockSelectionSet, @unchecked Sendable {
       typealias Schema = MockSchemaMetadata
 
@@ -498,12 +512,5 @@ final class JSONResponseParsingInterceptorTests_IncrementalItems: XCTestCase {
         }
       }
     }
-
-    override class var deferredFragments: [DeferredFragmentIdentifier: any SelectionSet.Type]? {
-      [
-        DeferredFragmentIdentifier(label: "deferredGenus", fieldPath: ["animal"]): AnAnimal.Animal.DeferredGenus.self,
-        DeferredFragmentIdentifier(label: "deferredFriend", fieldPath: ["animal"]): AnAnimal.Animal.DeferredFriend.self,
-      ]
-    }
   }
 }

Tests/ApolloTests/Network/ApolloURLSessionTests.swift

@@ -28,7 +28,6 @@ class ApolloURLSessionTests: XCTestCase, MockResponseProvider {
     var operation = MockQuery<MockSelectionSet>.mock()
     var additionalHeaders: [String: String] = [:]
     var cachePolicy: Apollo.CachePolicy = .fetchIgnoringCacheCompletely
-    var context: (any RequestContext)? = nil
     var clientAwarenessMetadata: ClientAwarenessMetadata = .none
 
     var urlRequest: URLRequest