Rename allowCachedErrors -> serverErrorsAsCacheMisses and allowCachePartialResults -> throwOnCacheMiss

Author: BoD

normalized-cache/api/normalized-cache.api

@@ -712,11 +712,11 @@ public final class com/apollographql/cache/normalized/memory/MemoryCacheFactory
 	public fun create ()Lcom/apollographql/cache/normalized/memory/MemoryCache;
 }
 
-public final class com/apollographql/cache/normalized/options/FetchAllowCachedErrorsKt {
-	public static final fun allowCachedErrors (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
+public final class com/apollographql/cache/normalized/options/ServerErrorsAsCacheMissesKt {
+	public static final fun serverErrorsAsCacheMisses (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
 }
 
-public final class com/apollographql/cache/normalized/options/FetchAllowCachedPartialResultsKt {
-	public static final fun allowCachedPartialResults (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
+public final class com/apollographql/cache/normalized/options/ThrowOnCacheMissKt {
+	public static final fun throwOnCacheMiss (Lcom/apollographql/apollo/api/MutableExecutionOptions;Z)Ljava/lang/Object;
 }
 

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

@@ -627,8 +627,8 @@ final fun <#A: com.apollographql.apollo.api/Operation.Data> (com.apollographql.a
 final fun <#A: com.apollographql.apollo.api/Operation.Data> (com.apollographql.apollo.api/ApolloResponse<#A>).com.apollographql.cache.normalized/errorsAsException(): com.apollographql.apollo.api/ApolloResponse<#A> // com.apollographql.cache.normalized/errorsAsException|errorsAsException@com.apollographql.apollo.api.ApolloResponse<0:0>(){0§<com.apollographql.apollo.api.Operation.Data>}[0]
 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.options/allowCachedErrors(kotlin/Boolean): #A // com.apollographql.cache.normalized.options/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.options/allowCachedPartialResults(kotlin/Boolean): #A // com.apollographql.cache.normalized.options/allowCachedPartialResults|allowCachedPartialResults@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.options/serverErrorsAsCacheMisses(kotlin/Boolean): #A // com.apollographql.cache.normalized.options/serverErrorsAsCacheMisses|serverErrorsAsCacheMisses@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.options/throwOnCacheMiss(kotlin/Boolean): #A // com.apollographql.cache.normalized.options/throwOnCacheMiss|throwOnCacheMiss@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/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/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/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]

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

@@ -10,8 +10,6 @@ enum class FetchPolicy {
 
   /**
    * Emit the response from the cache only.
-   *
-   * Equivalent of executing with `onlyIfCached(true)`.
    */
   CacheOnly,
 
@@ -22,16 +20,12 @@ enum class FetchPolicy {
 
   /**
    * Emit the response(s) from the network only.
-   *
-   * Equivalent of executing with `noCache(true)`.
    */
   NetworkOnly,
 
   /**
    * Emit the response from the cache first, and then emit the response(s) from the network.
-   *
-   * Equivalent of executing with `onlyIfCached(true)` and then with `noCache(true)`.
    */
-  @Deprecated("This is equivalent of executing with onlyIfCached(true) and then with noCache(true)")
+  @Deprecated("This is equivalent of executing with CacheOnly and then with NetworkOnly")
   CacheAndNetwork,
 }

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

@@ -13,10 +13,10 @@ import com.apollographql.apollo.exception.CacheMissException
 import com.apollographql.apollo.exception.DefaultApolloException
 import com.apollographql.apollo.interceptor.ApolloInterceptor
 import com.apollographql.apollo.interceptor.ApolloInterceptorChain
-import com.apollographql.cache.normalized.options.allowCachedErrors
-import com.apollographql.cache.normalized.options.allowCachedPartialResults
 import com.apollographql.cache.normalized.options.noCache
 import com.apollographql.cache.normalized.options.onlyIfCached
+import com.apollographql.cache.normalized.options.serverErrorsAsCacheMisses
+import com.apollographql.cache.normalized.options.throwOnCacheMiss
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emitAll
 import kotlinx.coroutines.flow.flow
@@ -47,7 +47,7 @@ val DefaultFetchPolicyInterceptor = object : ApolloInterceptor {
                 .fetchFromCache(true)
                 .build()
         ).single()
-            .errorsAsException(allowCachedPartialResults = request.allowCachedPartialResults, allowCachedErrors = request.allowCachedErrors)
+            .errorsAsException(throwOnCacheMiss = request.throwOnCacheMiss, serverErrorsAsCacheMisses = request.serverErrorsAsCacheMisses)
         emit(cacheResponse.newBuilder().isLast(request.onlyIfCached || cacheResponse.exception == null)
             .build()
         )
@@ -99,7 +99,7 @@ val NetworkFirstInterceptor = object : ApolloInterceptor {
               .fetchFromCache(true)
               .build()
       ).single()
-          .errorsAsException(allowCachedPartialResults = request.allowCachedPartialResults, allowCachedErrors = request.allowCachedErrors)
+          .errorsAsException(throwOnCacheMiss = request.throwOnCacheMiss, serverErrorsAsCacheMisses = request.serverErrorsAsCacheMisses)
       emit(cacheResponse)
     }
   }
@@ -118,7 +118,7 @@ val CacheAndNetworkInterceptor = object : ApolloInterceptor {
               .fetchFromCache(true)
               .build()
       ).single()
-          .errorsAsException(allowCachedPartialResults = request.allowCachedPartialResults, allowCachedErrors = request.allowCachedErrors)
+          .errorsAsException(throwOnCacheMiss = request.throwOnCacheMiss, serverErrorsAsCacheMisses = request.serverErrorsAsCacheMisses)
 
       emit(cacheResponse.newBuilder().isLast(false).build())
 
@@ -149,21 +149,21 @@ fun <D : Operation.Data> ApolloResponse<D>.errorsAsException(): ApolloResponse<D
 }
 
 private fun <D : Operation.Data> ApolloResponse<D>.errorsAsException(
-    allowCachedPartialResults: Boolean,
-    allowCachedErrors: Boolean,
+    throwOnCacheMiss: Boolean,
+    serverErrorsAsCacheMisses: Boolean,
 ): ApolloResponse<D> {
-  return if (allowCachedPartialResults && allowCachedErrors) {
+  return if (!throwOnCacheMiss && !serverErrorsAsCacheMisses) {
     this
   } else {
-    val cacheMissException = if (allowCachedPartialResults) {
+    val cacheMissException = if (!throwOnCacheMiss) {
       null
     } else {
       errors.orEmpty().mapNotNull { it.cacheMissException }.reduceOrNull { acc, e ->
         acc.addSuppressed(e)
         acc
       }
     }
-    val cachedErrorException = if (allowCachedErrors) {
+    val cachedErrorException = if (!serverErrorsAsCacheMisses) {
       null
     } else {
       errors.orEmpty().mapNotNull { if (it.cacheMissException != null) null else ApolloGraphQLException(it) }.reduceOrNull { acc, e ->

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/options/fetchAllowCachedErrors.kt

@@ -0,0 +1,27 @@
+package com.apollographql.cache.normalized.options
+
+import com.apollographql.apollo.api.ExecutionContext
+import com.apollographql.apollo.api.ExecutionOptions
+import com.apollographql.apollo.api.MutableExecutionOptions
+
+internal class ServerErrorsAsCacheMisses(val value: Boolean) : ExecutionContext.Element {
+  override val key: ExecutionContext.Key<*>
+    get() = Key
+
+  companion object Key : ExecutionContext.Key<ServerErrorsAsCacheMisses>
+}
+
+/**
+ * Sets whether GraphQL errors in the cache should be treated as cache misses.
+ *
+ * When true, if any field is an Error in the cache, the returned response will have a null data and a non-null exception of type
+ * [com.apollographql.apollo.exception.ApolloGraphQLException].
+ *
+ * Default: true
+ */
+internal val ExecutionOptions.serverErrorsAsCacheMisses: Boolean
+  get() = executionContext[ServerErrorsAsCacheMisses]?.value ?: true
+
+fun <T> MutableExecutionOptions<T>.serverErrorsAsCacheMisses(serverErrorsAsCacheMisses: Boolean): T =
+  addExecutionContext(ServerErrorsAsCacheMisses(serverErrorsAsCacheMisses))
+

normalized-cache/src/commonMain/kotlin/com/apollographql/cache/normalized/options/fetchAllowCachedPartialResults.kt

@@ -0,0 +1,29 @@
+package com.apollographql.cache.normalized.options
+
+import com.apollographql.apollo.api.ExecutionContext
+import com.apollographql.apollo.api.ExecutionOptions
+import com.apollographql.apollo.api.MutableExecutionOptions
+
+internal class ThrowOnCacheMissContext(val value: Boolean) : ExecutionContext.Element {
+  override val key: ExecutionContext.Key<*>
+    get() = Key
+
+  companion object Key : ExecutionContext.Key<ThrowOnCacheMissContext>
+}
+
+internal val ExecutionOptions.throwOnCacheMiss: Boolean
+  get() = executionContext[ThrowOnCacheMissContext]?.value ?: true
+
+/**
+ * Sets whether missing fields from the cache should result in an exception.
+ *
+ * When true, if any field is missing in the cache, the returned response will have a null data and a non-null exception of type
+ * [com.apollographql.apollo.exception.CacheMissException].
+ *
+ * Set this to false to allow partial responses from the cache, where _some_ or _all_ of the fields may be missing.
+ *
+ * Default: true
+ */
+fun <T> MutableExecutionOptions<T>.throwOnCacheMiss(throwOnCacheMiss: Boolean): T =
+  addExecutionContext(ThrowOnCacheMissContext(throwOnCacheMiss))
+