Do not throw in Flows

libraries/apollo-annotations/api/apollo-annotations.api

@@ -20,6 +20,8 @@ public final class com/apollographql/apollo3/annotations/ApolloDeprecatedSince$V
 	public static final field v3_5_1 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static final field v3_6_3 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static final field v3_7_2 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
+	public static final field v3_7_5 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
+	public static final field v4_0_0 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static fun valueOf (Ljava/lang/String;)Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static fun values ()[Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 }

libraries/apollo-annotations/src/commonMain/kotlin/com/apollographql/apollo3/annotations/ApolloDeprecatedSince.kt

@@ -26,6 +26,8 @@ annotation class ApolloDeprecatedSince(val version: Version) {
     v3_4_1,
     v3_5_1,
     v3_6_3,
-    v3_7_2
+    v3_7_2,
+    v3_7_5,
+    v4_0_0,
   }
 }

libraries/apollo-api/api/apollo-api.api

@@ -60,7 +60,7 @@ public final class com/apollographql/apollo3/api/ApolloOptionalAdapter : com/apo
 }
 
 public final class com/apollographql/apollo3/api/ApolloRequest : com/apollographql/apollo3/api/ExecutionOptions {
-	public synthetic fun <init> (Lcom/apollographql/apollo3/api/Operation;Ljava/util/UUID;Lcom/apollographql/apollo3/api/ExecutionContext;Lcom/apollographql/apollo3/api/http/HttpMethod;Ljava/util/List;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Lcom/apollographql/apollo3/api/Operation;Ljava/util/UUID;Lcom/apollographql/apollo3/api/ExecutionContext;Lcom/apollographql/apollo3/api/http/HttpMethod;Ljava/util/List;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Ljava/lang/Boolean;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun getCanBeBatched ()Ljava/lang/Boolean;
 	public fun getEnableAutoPersistedQueries ()Ljava/lang/Boolean;
 	public fun getExecutionContext ()Lcom/apollographql/apollo3/api/ExecutionContext;
@@ -113,12 +113,13 @@ public final class com/apollographql/apollo3/api/ApolloRequest$Builder : com/apo
 public final class com/apollographql/apollo3/api/ApolloResponse {
 	public final field data Lcom/apollographql/apollo3/api/Operation$Data;
 	public final field errors Ljava/util/List;
+	public final field exception Lcom/apollographql/apollo3/exception/ApolloException;
 	public final field executionContext Lcom/apollographql/apollo3/api/ExecutionContext;
 	public final field extensions Ljava/util/Map;
 	public final field isLast Z
 	public final field operation Lcom/apollographql/apollo3/api/Operation;
 	public final field requestUuid Ljava/util/UUID;
-	public synthetic fun <init> (Ljava/util/UUID;Lcom/apollographql/apollo3/api/Operation;Lcom/apollographql/apollo3/api/Operation$Data;Ljava/util/List;Ljava/util/Map;Lcom/apollographql/apollo3/api/ExecutionContext;ZLkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/util/UUID;Lcom/apollographql/apollo3/api/Operation;Lcom/apollographql/apollo3/api/Operation$Data;Ljava/util/List;Lcom/apollographql/apollo3/exception/ApolloException;Ljava/util/Map;Lcom/apollographql/apollo3/api/ExecutionContext;ZLkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun dataAssertNoErrors ()Lcom/apollographql/apollo3/api/Operation$Data;
 	public final fun hasErrors ()Z
 	public final fun newBuilder ()Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
@@ -129,6 +130,7 @@ public final class com/apollographql/apollo3/api/ApolloResponse$Builder {
 	public final fun addExecutionContext (Lcom/apollographql/apollo3/api/ExecutionContext;)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
 	public final fun build ()Lcom/apollographql/apollo3/api/ApolloResponse;
 	public final fun errors (Ljava/util/List;)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
+	public final fun exception (Lcom/apollographql/apollo3/exception/ApolloException;)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
 	public final fun extensions (Ljava/util/Map;)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
 	public final fun isLast (Z)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
 	public final fun requestUuid (Ljava/util/UUID;)Lcom/apollographql/apollo3/api/ApolloResponse$Builder;
@@ -1148,6 +1150,7 @@ public final class com/apollographql/apollo3/api/test/TestResolverKt {
 
 public final class com/apollographql/apollo3/exception/ApolloCompositeException : com/apollographql/apollo3/exception/ApolloException {
 	public fun <init> (Ljava/lang/Throwable;Ljava/lang/Throwable;)V
+	public fun <init> (Ljava/util/List;)V
 }
 
 public class com/apollographql/apollo3/exception/ApolloException : java/lang/RuntimeException {

libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/ApolloRequest.kt

@@ -1,6 +1,7 @@
 package com.apollographql.apollo3.api
 
 import com.apollographql.apollo3.annotations.ApolloExperimental
+import com.apollographql.apollo3.annotations.ApolloInternal
 import com.apollographql.apollo3.api.http.HttpHeader
 import com.apollographql.apollo3.api.http.HttpMethod
 import com.benasher44.uuid.Uuid
@@ -20,12 +21,16 @@ private constructor(
     override val sendDocument: Boolean?,
     override val enableAutoPersistedQueries: Boolean?,
     override val canBeBatched: Boolean?,
+
+    @ApolloInternal
+    val useV3ExceptionHandling: Boolean?,
 ) : ExecutionOptions {
 
   fun newBuilder(): Builder<D> = newBuilder(operation)
 
   @ApolloExperimental
   fun <E: Operation.Data> newBuilder(operation: Operation<E>): Builder<E> {
+    @Suppress("DEPRECATION")
     return Builder(operation)
         .requestUuid(requestUuid)
         .executionContext(executionContext)
@@ -35,7 +40,7 @@ private constructor(
         .sendDocument(sendDocument)
         .enableAutoPersistedQueries(enableAutoPersistedQueries)
         .canBeBatched(canBeBatched)
-
+        .useV3ExceptionHandling(useV3ExceptionHandling)
   }
 
   class Builder<D : Operation.Data>(
@@ -84,6 +89,13 @@ private constructor(
       this.canBeBatched = canBeBatched
     }
 
+    private var useV3ExceptionHandling: Boolean? = null
+
+    @ApolloInternal
+    fun useV3ExceptionHandling(useV3ExceptionHandling: Boolean?): Builder<D> = apply {
+      this.useV3ExceptionHandling = useV3ExceptionHandling
+    }
+
     fun requestUuid(requestUuid: Uuid) = apply {
       this.requestUuid = requestUuid
     }
@@ -108,6 +120,7 @@ private constructor(
           sendDocument = sendDocument,
           enableAutoPersistedQueries = enableAutoPersistedQueries,
           canBeBatched = canBeBatched,
+          useV3ExceptionHandling = useV3ExceptionHandling,
       )
     }
   }

libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/ApolloResponse.kt

@@ -27,12 +27,28 @@ private constructor(
     val data: D?,
 
     /**
-     * GraphQL [operation] execution errors returned by the server to let client know that something has gone wrong.
-     * This can either be null or empty depending on what your server sends back
+     * [GraphQL errors](https://spec.graphql.org/October2021/#sec-Errors) returned by the server to let the client know that something
+     * has gone wrong.
+     *
+     * If no GraphQL error was raised, [errors] is null. Else it's a non-empty list of errors indicating where the error(s) happened.
+     *
+     * Note that because GraphQL allows partial data, it is possible to have both [data] non null and [errors] non null.
+     *
+     * See also [exception] for exceptions happening before a valid GraphQL response could be received.
      */
     @JvmField
     val errors: List<Error>?,
 
+    /**
+     * An [ApolloException] if a valid GraphQL response wasn't received or `null` if a valid GraphQL response was received.
+     * For example, `exception` is non null if there is a network failure or cache miss.
+     * If `exception` is non null, [data] and [errors] will be null.
+     *
+     * See also [errors] for GraphQL errors returned by the server.
+     */
+    @JvmField
+    val exception: ApolloException?,
+
     /**
      * Extensions of GraphQL protocol, arbitrary map of key [String] / value [Any] sent by server along with the response.
      */
@@ -71,10 +87,10 @@ private constructor(
   @get:JvmName("dataAssertNoErrors")
   val dataAssertNoErrors: D
     get() {
-      return if (hasErrors()) {
-        throw ApolloException("The response has errors: $errors")
-      } else {
-        data ?: throw  ApolloException("The server did not return any data")
+      return when {
+        exception != null -> throw exception
+        hasErrors() -> throw ApolloException("The response has errors: $errors")
+        else -> data ?: throw ApolloException("The server did not return any data")
       }
     }
 
@@ -83,6 +99,7 @@ private constructor(
   fun newBuilder(): Builder<D> {
     return Builder(operation, requestUuid, data)
         .errors(errors)
+        .exception(exception)
         .extensions(extensions)
         .addExecutionContext(executionContext)
         .isLast(isLast)
@@ -95,6 +112,7 @@ private constructor(
   ) {
     private var executionContext: ExecutionContext = ExecutionContext.Empty
     private var errors: List<Error>? = null
+    private var exception: ApolloException? = null
     private var extensions: Map<String, Any?>? = null
     private var isLast = false
 
@@ -106,6 +124,10 @@ private constructor(
       this.errors = errors
     }
 
+    fun exception(exception: ApolloException?) = apply {
+      this.exception = exception
+    }
+
     fun extensions(extensions: Map<String, Any?>?) = apply {
       this.extensions = extensions
     }
@@ -127,6 +149,7 @@ private constructor(
           executionContext = executionContext,
           extensions = extensions ?: emptyMap(),
           errors = errors,
+          exception = exception,
           isLast = isLast,
       )
     }

libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/ExecutionOptions.kt

@@ -22,26 +22,27 @@ interface ExecutionOptions {
   val httpHeaders: List<HttpHeader>?
 
   /**
-   *
-   * Whether to send the Auto Persisted Queries extensions
+   * Whether to send the Auto Persisted Queries extensions.
    * Used by [com.apollographql.apollo3.api.http.DefaultHttpRequestComposer]
    */
   val sendApqExtensions: Boolean?
 
   /**
-   *
-   * Whether to send the document
+   * Whether to send the document.
    * Used by [com.apollographql.apollo3.api.http.DefaultHttpRequestComposer]
    */
   val sendDocument: Boolean?
 
   /**
-   *
-   * Whether to enable Auto Persisted Queries and try to send a hashed query first
+   * Whether to enable Auto Persisted Queries and try to send a hashed query first.
    * Used by [com.apollographql.apollo3.interceptor.AutoPersistedQueryInterceptor]
    */
   val enableAutoPersistedQueries: Boolean?
 
+  /**
+   * Whether the request can be batched.
+   * Used by [com.apollographql.apollo3.network.http.BatchingHttpInterceptor]
+   */
   val canBeBatched: Boolean?
 
   companion object {

libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/Operations.kt

@@ -8,7 +8,10 @@ import com.apollographql.apollo3.api.json.JsonReader
 import com.apollographql.apollo3.api.json.JsonWriter
 import com.apollographql.apollo3.api.json.jsonReader
 import com.apollographql.apollo3.api.json.writeObject
+import com.apollographql.apollo3.exception.JsonDataException
+import com.apollographql.apollo3.exception.JsonEncodingException
 import okio.Buffer
+import okio.IOException
 import okio.use
 import kotlin.jvm.JvmName
 import kotlin.jvm.JvmOverloads
@@ -53,6 +56,10 @@ fun <D : Operation.Data> Operation<D>.composeJsonRequest(
  * ```
  *
  * This method takes ownership of [jsonReader] and will always close it
+ *
+ * @throws IOException if reading [jsonReader] fails
+ * @throws JsonEncodingException if the data is not valid json
+ * @throws JsonDataException if the data is not of the expected type
  */
 @JvmOverloads
 fun <D : Operation.Data> Operation<D>.parseJsonResponse(

libraries/apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/exception/Exceptions.kt

@@ -104,7 +104,7 @@ class CacheMissException @ApolloInternal constructor(
   @ApolloExperimental
   val stale: Boolean = stale
 
-  constructor(key: String, fieldName: String?): this(key, fieldName, false)
+  constructor(key: String, fieldName: String?) : this(key, fieldName, false)
 
   companion object {
     internal fun message(key: String?, fieldName: String?, stale: Boolean): String {
@@ -158,12 +158,15 @@ class HttpCacheMissException(message: String, cause: Exception? = null) : Apollo
  *   }
  * ```
  */
-class ApolloCompositeException(first: Throwable?, second: Throwable?) : ApolloException(message = "multiple exceptions happened", second) {
-  init {
+class ApolloCompositeException : ApolloException {
+  constructor(first: Throwable?, second: Throwable?) : super(message = "Multiple exceptions happened", second) {
     if (first != null) addSuppressed(first)
     if (second != null) addSuppressed(second)
   }
 
+  constructor(exceptions: List<Throwable>) : super(message = "Multiple exceptions happened", exceptions.lastOrNull()) {
+    exceptions.forEach { addSuppressed(it) }
+  }
 }
 
 class AutoPersistedQueriesNotSupported : ApolloException(message = "The server does not support auto persisted queries")

libraries/apollo-http-cache/src/main/kotlin/com/apollographql/apollo3/cache/http/HttpCacheExtensions.kt

@@ -22,7 +22,6 @@ import com.apollographql.apollo3.network.http.HttpInterceptor
 import com.apollographql.apollo3.network.http.HttpInterceptorChain
 import com.apollographql.apollo3.network.http.HttpNetworkTransport
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
@@ -120,15 +119,10 @@ fun ApolloClient.Builder.httpCache(
       )
           .run {
             if (request.operation is Query<*> || request.operation is Mutation<*>) {
-              catch { throwable ->
+              onEach { response ->
                 // Revert caching of responses with errors
                 val cacheKey = synchronized(apolloRequestToCacheKey) { apolloRequestToCacheKey[request.requestUuid.toString()] }
-                cacheKey?.let { cachingHttpInterceptor.cache.remove(it) }
-                throw throwable
-              }.onEach { response ->
-                // Revert caching of responses with errors
-                val cacheKey = synchronized(apolloRequestToCacheKey) { apolloRequestToCacheKey[request.requestUuid.toString()] }
-                if (response.hasErrors()) {
+                if (response.hasErrors() || response.exception != null) {
                   cacheKey?.let { cachingHttpInterceptor.cache.remove(it) }
                 }
               }.onCompletion {

libraries/apollo-normalized-cache-incubating/src/commonMain/kotlin/com/apollographql/apollo3/cache/normalized/CacheMissLoggingInterceptor.kt

@@ -1,26 +1,20 @@
 package com.apollographql.apollo3.cache.normalized
 
-import com.apollographql.apollo3.interceptor.ApolloInterceptor
-import com.apollographql.apollo3.interceptor.ApolloInterceptorChain
 import com.apollographql.apollo3.api.ApolloRequest
 import com.apollographql.apollo3.api.ApolloResponse
 import com.apollographql.apollo3.api.Operation
 import com.apollographql.apollo3.exception.CacheMissException
+import com.apollographql.apollo3.interceptor.ApolloInterceptor
+import com.apollographql.apollo3.interceptor.ApolloInterceptorChain
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.onEach
 
 class CacheMissLoggingInterceptor(private val log: (String) -> Unit) : ApolloInterceptor {
   override fun <D : Operation.Data> intercept(request: ApolloRequest<D>, chain: ApolloInterceptorChain): Flow<ApolloResponse<D>> {
     return chain.proceed(request).onEach {
-      it.cacheInfo?.cacheMissException?.message?.let {
-        log(it)
-      }
-    }.catch { throwable ->
-      if (throwable is CacheMissException) {
-        log(throwable.message.toString())
+      if (it.exception is CacheMissException) {
+        log(it.exception!!.message.toString())
       }
-      throw throwable
     }
   }
-}
+}