Add allowPartialResults and allowCachedErrors

Author: BoD

normalized-cache/api/normalized-cache.api

@@ -179,11 +179,12 @@ public final class com/apollographql/cache/normalized/NormalizedCache {
 	public static final fun -logCacheMisses (Lcom/apollographql/apollo/ApolloClient$Builder;Lkotlin/jvm/functions/Function1;)Lcom/apollographql/apollo/ApolloClient$Builder;
 	public static synthetic fun -logCacheMisses$default (Lcom/apollographql/apollo/ApolloClient$Builder;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lcom/apollographql/apollo/ApolloClient$Builder;
 	public static final fun addCacheHeader (Lcom/apollographql/apollo/api/MutableExecutionOptions;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
+	public static final fun allowCachedErrors (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
+	public static final fun allowPartialResults (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
 	public static final fun cacheHeaders (Lcom/apollographql/apollo/api/ApolloResponse$Builder;Lcom/apollographql/cache/normalized/api/CacheHeaders;)Lcom/apollographql/apollo/api/ApolloResponse$Builder;
 	public static final fun cacheHeaders (Lcom/apollographql/apollo/api/MutableExecutionOptions;Lcom/apollographql/cache/normalized/api/CacheHeaders;)Ljava/lang/Object;
 	public static final fun cacheManager (Lcom/apollographql/apollo/ApolloClient$Builder;Lcom/apollographql/cache/normalized/CacheManager;Z)Lcom/apollographql/apollo/ApolloClient$Builder;
 	public static synthetic fun cacheManager$default (Lcom/apollographql/apollo/ApolloClient$Builder;Lcom/apollographql/cache/normalized/CacheManager;ZILjava/lang/Object;)Lcom/apollographql/apollo/ApolloClient$Builder;
-	public static final fun cachePolicyResponseMapper (Lcom/apollographql/apollo/api/MutableExecutionOptions;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
 	public static final fun clock (Lcom/apollographql/apollo/api/MutableExecutionOptions;Lkotlin/jvm/functions/Function0;)Ljava/lang/Object;
 	public static final fun configureApolloClientBuilder2 (Lcom/apollographql/apollo/ApolloClient$Builder;Lcom/apollographql/cache/normalized/api/NormalizedCacheFactory;)Lcom/apollographql/apollo/ApolloClient$Builder;
 	public static final fun configureApolloClientBuilder2 (Lcom/apollographql/apollo/ApolloClient$Builder;Lcom/apollographql/cache/normalized/api/NormalizedCacheFactory;Lcom/apollographql/cache/normalized/api/CacheKeyGenerator;)Lcom/apollographql/apollo/ApolloClient$Builder;

normalized-cache/api/normalized-cache.klib.api

@@ -632,8 +632,9 @@ final fun <#A: com.apollographql.apollo.api/Operation.Data> (com.apollographql.a
 final fun <#A: com.apollographql.apollo.api/Query.Data> (com.apollographql.apollo/ApolloCall<#A>).com.apollographql.cache.normalized/watch(#A?): kotlinx.coroutines.flow/Flow<com.apollographql.apollo.api/ApolloResponse<#A>> // com.apollographql.cache.normalized/watch|watch@com.apollographql.apollo.ApolloCall<0:0>(0:0?){0§<com.apollographql.apollo.api.Query.Data>}[0]
 final fun <#A: com.apollographql.apollo.api/Query.Data> (com.apollographql.apollo/ApolloCall<#A>).com.apollographql.cache.normalized/watch(): kotlinx.coroutines.flow/Flow<com.apollographql.apollo.api/ApolloResponse<#A>> // com.apollographql.cache.normalized/watch|watch@com.apollographql.apollo.ApolloCall<0:0>(){0§<com.apollographql.apollo.api.Query.Data>}[0]
 final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/addCacheHeader(kotlin/String, kotlin/String): #A // com.apollographql.cache.normalized/addCacheHeader|addCacheHeader@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.String;kotlin.String){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/allowCachedErrors(kotlin/Boolean): #A // com.apollographql.cache.normalized/allowCachedErrors|allowCachedErrors@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Boolean){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/allowPartialResults(kotlin/Boolean): #A // com.apollographql.cache.normalized/allowPartialResults|allowPartialResults@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Boolean){0§<kotlin.Any?>}[0]
 final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/cacheHeaders(com.apollographql.cache.normalized.api/CacheHeaders): #A // com.apollographql.cache.normalized/cacheHeaders|cacheHeaders@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(com.apollographql.cache.normalized.api.CacheHeaders){0§<kotlin.Any?>}[0]
-final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/cachePolicyResponseMapper(kotlin/Function2<com.apollographql.apollo.api/ApolloResponse<*>, com.apollographql.cache.normalized/FetchPolicy, com.apollographql.apollo.api/ApolloResponse<*>>): #A // com.apollographql.cache.normalized/cachePolicyResponseMapper|cachePolicyResponseMapper@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Function2<com.apollographql.apollo.api.ApolloResponse<*>,com.apollographql.cache.normalized.FetchPolicy,com.apollographql.apollo.api.ApolloResponse<*>>){0§<kotlin.Any?>}[0]
 final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/clock(kotlin/Function0<kotlin/Long>): #A // com.apollographql.cache.normalized/clock|clock@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Function0<kotlin.Long>){0§<kotlin.Any?>}[0]
 final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/doNotStore(kotlin/Boolean): #A // com.apollographql.cache.normalized/doNotStore|doNotStore@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Boolean){0§<kotlin.Any?>}[0]
 final fun <#A: kotlin/Any?> (com.apollographql.apollo.api/MutableExecutionOptions<#A>).com.apollographql.cache.normalized/errorsReplaceCachedValues(kotlin/Boolean): #A // com.apollographql.cache.normalized/errorsReplaceCachedValues|errorsReplaceCachedValues@com.apollographql.apollo.api.MutableExecutionOptions<0:0>(kotlin.Boolean){0§<kotlin.Any?>}[0]

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/ClientCacheExtensions.kt

@@ -754,26 +754,28 @@ fun <T> MutableExecutionOptions<T>.clock(clock: () -> Long): T {
   return this as T
 }
 
-internal class CachePolicyResponseMapperContext(val value: (ApolloResponse<*>, FetchPolicy) -> ApolloResponse<*>) :
-  ExecutionContext.Element {
+internal class AllowPartialResults(val value: Boolean) : ExecutionContext.Element {
   override val key: ExecutionContext.Key<*>
     get() = Key
 
-  companion object Key : ExecutionContext.Key<CachePolicyResponseMapperContext>
+  companion object Key : ExecutionContext.Key<AllowPartialResults>
 }
 
-private val defaultCachePolicyResponseMapper: (ApolloResponse<*>, FetchPolicy) -> ApolloResponse<*> = { response, _ ->
-  response.errorsAsException()
-}
+internal val ExecutionOptions.allowPartialResults: Boolean
+  get() = executionContext[AllowPartialResults]?.value ?: false
 
-internal val ExecutionOptions.cachePolicyResponseMapper: ((ApolloResponse<*>, FetchPolicy) -> ApolloResponse<*>)
-  get() = executionContext[CachePolicyResponseMapperContext]?.value ?: defaultCachePolicyResponseMapper
+fun <T> MutableExecutionOptions<T>.allowPartialResults(allowPartialResults: Boolean): T =
+  addExecutionContext(AllowPartialResults(allowPartialResults))
 
-/**
- * Sets a response mapper that will be used inside the built-in fetch policies interceptors to transform the responses from the cache.
- */
-fun <T> MutableExecutionOptions<T>.cachePolicyResponseMapper(mapper: (ApolloResponse<*>, FetchPolicy) -> ApolloResponse<*>): T {
-  addExecutionContext(CachePolicyResponseMapperContext(mapper))
-  @Suppress("UNCHECKED_CAST")
-  return this as T
+internal class AllowCachedErrors(val value: Boolean) : ExecutionContext.Element {
+  override val key: ExecutionContext.Key<*>
+    get() = Key
+
+  companion object Key : ExecutionContext.Key<AllowCachedErrors>
 }
+
+internal val ExecutionOptions.allowCachedErrors: Boolean
+  get() = executionContext[AllowCachedErrors]?.value ?: false
+
+fun <T> MutableExecutionOptions<T>.allowCachedErrors(allowCachedErrors: Boolean): T =
+  addExecutionContext(AllowCachedErrors(allowCachedErrors))

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/FetchPolicyInterceptors.kt

@@ -34,8 +34,7 @@ val CacheOnlyInterceptor = object : ApolloInterceptor {
             .fetchFromCache(true)
             .build()
     ).map {
-      @Suppress("UNCHECKED_CAST")
-      request.cachePolicyResponseMapper(it, FetchPolicy.CacheOnly) as ApolloResponse<D>
+      it.errorsAsException(allowPartialResults = request.allowPartialResults, allowCachedErrors = request.allowCachedErrors)
     }
   }
 }
@@ -60,10 +59,7 @@ val CacheFirstInterceptor = object : ApolloInterceptor {
               .newBuilder()
               .fetchFromCache(true)
               .build()
-      ).single().let {
-        @Suppress("UNCHECKED_CAST")
-        request.cachePolicyResponseMapper(it, FetchPolicy.CacheFirst) as ApolloResponse<D>
-      }
+      ).single().errorsAsException(allowPartialResults = request.allowPartialResults, allowCachedErrors = request.allowCachedErrors)
       emit(cacheResponse.newBuilder().isLast(cacheResponse.exception == null).build())
       if (cacheResponse.exception == null) {
         return@flow
@@ -109,10 +105,7 @@ val NetworkFirstInterceptor = object : ApolloInterceptor {
               .newBuilder()
               .fetchFromCache(true)
               .build()
-      ).single().let {
-        @Suppress("UNCHECKED_CAST")
-        request.cachePolicyResponseMapper(it, FetchPolicy.NetworkFirst) as ApolloResponse<D>
-      }
+      ).single().errorsAsException(allowPartialResults = request.allowPartialResults, allowCachedErrors = request.allowCachedErrors)
       emit(cacheResponse)
     }
   }
@@ -129,10 +122,7 @@ val CacheAndNetworkInterceptor = object : ApolloInterceptor {
               .newBuilder()
               .fetchFromCache(true)
               .build()
-      ).single().let {
-        @Suppress("UNCHECKED_CAST")
-        request.cachePolicyResponseMapper(it, FetchPolicy.CacheAndNetwork) as ApolloResponse<D>
-      }
+      ).single().errorsAsException(allowPartialResults = request.allowPartialResults, allowCachedErrors = request.allowCachedErrors)
 
       emit(cacheResponse.newBuilder().isLast(false).build())
 
@@ -162,6 +152,57 @@ fun <D : Operation.Data> ApolloResponse<D>.errorsAsException(): ApolloResponse<D
   }
 }
 
+private fun <D : Operation.Data> ApolloResponse<D>.errorsAsException(
+    allowPartialResults: Boolean,
+    allowCachedErrors: Boolean,
+): ApolloResponse<D> {
+  return if (allowPartialResults && allowCachedErrors) {
+    this
+  } else {
+    val cacheMissException = if (allowPartialResults) {
+      null
+    } else {
+      errors.orEmpty().mapNotNull { it.cacheMissException }.reduceOrNull { acc, e ->
+        acc.addSuppressed(e)
+        acc
+      }
+    }
+    val cachedErrorException = if (allowCachedErrors) {
+      null
+    } else {
+      errors.orEmpty().mapNotNull { if (it.cacheMissException != null) null else ApolloGraphQLException(it) }.reduceOrNull { acc, e ->
+        acc.addSuppressed(e)
+        acc
+      }
+    }
+    when {
+      cacheMissException != null -> {
+        newBuilder()
+            .exception(cacheMissException.apply {
+              if (cachedErrorException != null) {
+                addSuppressed(cachedErrorException)
+              }
+            })
+            .data(null)
+            .errors(null)
+            .build()
+      }
+
+      cachedErrorException != null -> {
+        newBuilder()
+            .exception(cachedErrorException)
+            .data(null)
+            .errors(null)
+            .build()
+      }
+
+      else -> {
+        this
+      }
+    }
+  }
+}
+
 internal object FetchPolicyRouterInterceptor : ApolloInterceptor {
   override fun <D : Operation.Data> intercept(request: ApolloRequest<D>, chain: ApolloInterceptorChain): Flow<ApolloResponse<D>> {
     if (request.operation !is Query) {

tests/cache-policy-response-mapper/src/commonTest/kotlin/test/CachePolicyResponseMapperTest.kt

@@ -1,13 +1,12 @@
 package test
 
 import com.apollographql.apollo.ApolloClient
-import com.apollographql.apollo.api.ApolloResponse
 import com.apollographql.apollo.api.Error
 import com.apollographql.cache.normalized.CacheManager
 import com.apollographql.cache.normalized.FetchPolicy
+import com.apollographql.cache.normalized.allowCachedErrors
+import com.apollographql.cache.normalized.allowPartialResults
 import com.apollographql.cache.normalized.cacheManager
-import com.apollographql.cache.normalized.cacheMissException
-import com.apollographql.cache.normalized.cachePolicyResponseMapper
 import com.apollographql.cache.normalized.fetchPolicy
 import com.apollographql.cache.normalized.memory.MemoryCacheFactory
 import com.apollographql.cache.normalized.sql.SqlNormalizedCacheFactory
@@ -79,7 +78,6 @@ class StoreErrorsTest {
     ApolloClient.Builder()
         .serverUrl(mockServer.url())
         .cacheManager(cacheManager)
-        .cachePolicyResponseMapper(cachePolicyResponseMapper)
         .build()
         .use { apolloClient ->
           val networkResult = apolloClient.query(MeWithNickNameQuery())
@@ -105,6 +103,7 @@ class StoreErrorsTest {
           )
 
           val cacheResult = apolloClient.query(MeWithNickNameQuery())
+              .allowCachedErrors(true)
               .execute()
           assertEquals(
               networkResult.data,
@@ -168,7 +167,6 @@ class StoreErrorsTest {
     ApolloClient.Builder()
         .serverUrl(mockServer.url())
         .cacheManager(cacheManager)
-        .cachePolicyResponseMapper(cachePolicyResponseMapper)
         .build()
         .use { apolloClient ->
           val networkResult = apolloClient.query(UsersQuery(listOf("1", "2", "3")))
@@ -205,6 +203,7 @@ class StoreErrorsTest {
 
           val cacheResult = apolloClient.query(UsersQuery(listOf("1", "2", "3")))
               .fetchPolicy(FetchPolicy.CacheOnly)
+              .allowCachedErrors(true)
               .execute()
           assertEquals(
               networkResult.data,
@@ -258,7 +257,6 @@ class StoreErrorsTest {
     ApolloClient.Builder()
         .serverUrl(mockServer.url())
         .cacheManager(cacheManager)
-        .cachePolicyResponseMapper(cachePolicyResponseMapper)
         .build()
         .use { apolloClient ->
           val networkResult = apolloClient.query(MeWithNickNameQuery())
@@ -285,6 +283,8 @@ class StoreErrorsTest {
 
           val cacheResult = apolloClient.query(MeWithNickNameAndProjectQuery())
               .fetchPolicy(FetchPolicy.CacheOnly)
+              .allowPartialResults(true)
+              .allowCachedErrors(true)
               .execute()
           assertEquals(
               MeWithNickNameAndProjectQuery.Data(
@@ -309,28 +309,3 @@ class StoreErrorsTest {
   }
 
 }
-
-private val cachePolicyResponseMapper: (ApolloResponse<*>, FetchPolicy) -> ApolloResponse<*> = { response, fetchPolicy ->
-  when (fetchPolicy) {
-    FetchPolicy.CacheFirst -> {
-      val cacheMissException = response.errors.orEmpty().mapNotNull { it.cacheMissException }.reduceOrNull { acc, e ->
-        acc.addSuppressed(e)
-        acc
-      }
-      if (cacheMissException != null) {
-        response.newBuilder()
-            .exception(cacheMissException)
-            .data(null)
-            .errors(null)
-            .build()
-      } else {
-        response
-      }
-    }
-
-    FetchPolicy.CacheOnly -> response
-    FetchPolicy.NetworkFirst -> response
-    FetchPolicy.NetworkOnly -> response
-    FetchPolicy.CacheAndNetwork -> response
-  }
-}