feat: dataconnect: DataConnectOperationException added to support partial errors

firebase-dataconnect/CHANGELOG.md

@@ -2,6 +2,11 @@
 * [changed] Removed the "beta" suffix from the version of the Firebase Data
   Connect Android SDK, thus graduating it from "beta" to "generally available".
   ([#6792](https://github.com/firebase/firebase-android-sdk/pull/6792))
+* [changed] DataConnectOperationException added, enabling support for partial
+  errors; that is, any data that was received and/or was able to be decoded is
+  now available via the "response" property of the exception thrown when a
+  query or mutation is executed.
+  ([#6794](https://github.com/firebase/firebase-android-sdk/pull/6794))
 
 # 16.0.0-beta05
 * [changed] Changed gRPC proto package to v1 (was v1beta).

firebase-dataconnect/api.txt

@@ -42,6 +42,47 @@ package com.google.firebase.dataconnect {
     ctor public DataConnectException(String message, Throwable? cause = null);
   }
 
+  public class DataConnectOperationException extends com.google.firebase.dataconnect.DataConnectException {
+    ctor public DataConnectOperationException(String message, Throwable? cause = null, com.google.firebase.dataconnect.DataConnectOperationFailureResponse<? extends java.lang.Object?> response);
+    method public final com.google.firebase.dataconnect.DataConnectOperationFailureResponse<? extends java.lang.Object?> getResponse();
+    property public final com.google.firebase.dataconnect.DataConnectOperationFailureResponse<? extends java.lang.Object?> response;
+  }
+
+  public interface DataConnectOperationFailureResponse<Data> {
+    method public Data? getData();
+    method public java.util.List<com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo> getErrors();
+    method public java.util.Map<java.lang.String,java.lang.Object?>? getRawData();
+    method public String toString();
+    property public abstract Data? data;
+    property public abstract java.util.List<com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo> errors;
+    property public abstract java.util.Map<java.lang.String,java.lang.Object?>? rawData;
+  }
+
+  public static interface DataConnectOperationFailureResponse.ErrorInfo {
+    method public boolean equals(Object? other);
+    method public String getMessage();
+    method public java.util.List<com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo.PathSegment> getPath();
+    method public int hashCode();
+    method public String toString();
+    property public abstract String message;
+    property public abstract java.util.List<com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo.PathSegment> path;
+  }
+
+  public static sealed interface DataConnectOperationFailureResponse.ErrorInfo.PathSegment {
+  }
+
+  @kotlin.jvm.JvmInline public static final value class DataConnectOperationFailureResponse.ErrorInfo.PathSegment.Field implements com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo.PathSegment {
+    ctor public DataConnectOperationFailureResponse.ErrorInfo.PathSegment.Field(String field);
+    method public String getField();
+    property public final String field;
+  }
+
+  @kotlin.jvm.JvmInline public static final value class DataConnectOperationFailureResponse.ErrorInfo.PathSegment.ListIndex implements com.google.firebase.dataconnect.DataConnectOperationFailureResponse.ErrorInfo.PathSegment {
+    ctor public DataConnectOperationFailureResponse.ErrorInfo.PathSegment.ListIndex(int index);
+    method public int getIndex();
+    property public final int index;
+  }
+
   public final class DataConnectSettings {
     ctor public DataConnectSettings(String host = "firebasedataconnect.googleapis.com", boolean sslEnabled = true);
     method public String getHost();

firebase-dataconnect/emulator/dataconnect/connector/person/person_ops.gql

@@ -88,3 +88,14 @@ query getPersonAuth($id: String!) @auth(level: USER_ANON) {
     age
   }
 }
+
+query getPersonWithPartialFailure($id: String!) @auth(level: PUBLIC) {
+  person1: person(id: $id) { name }
+  person2: person(id: $id) @check(expr: "false", message: "c8azjdwz2x") { name }
+}
+
+mutation createPersonWithPartialFailure($id: String!, $name: String!) @auth(level: PUBLIC) {
+  person1: person_insert(data: { id: $id, name: $name })
+  person2: person_insert(data: { id_expr: "uuidV4()", name: $name }) @check(expr: "false", message: "ecxpjy4qfy")
+}
+

firebase-dataconnect/firebase-dataconnect.gradle.kts

@@ -102,6 +102,7 @@ dependencies {
 
   compileOnly(libs.javax.annotation.jsr250)
   compileOnly(libs.kotlinx.datetime)
+  compileOnly(libs.kotlinx.serialization.json)
   implementation(libs.grpc.android)
   implementation(libs.grpc.kotlin.stub)
   implementation(libs.grpc.okhttp)

firebase-dataconnect/src/androidTest/kotlin/com/google/firebase/dataconnect/OperationExecutionErrorsIntegrationTest.kt

@@ -0,0 +1,262 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.dataconnect
+
+import com.google.firebase.dataconnect.testutil.DataConnectIntegrationTestBase
+import com.google.firebase.dataconnect.testutil.schemas.PersonSchema
+import com.google.firebase.dataconnect.testutil.schemas.PersonSchema.CreatePersonMutation
+import com.google.firebase.dataconnect.testutil.schemas.PersonSchema.GetPersonQuery
+import com.google.firebase.dataconnect.testutil.shouldSatisfy
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.collections.shouldHaveAtLeastSize
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.map
+import io.kotest.property.arbitrary.next
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.serializer
+import org.junit.Test
+
+class OperationExecutionErrorsIntegrationTest : DataConnectIntegrationTestBase() {
+
+  private val personSchema: PersonSchema by lazy { PersonSchema(dataConnectFactory) }
+  private val dataConnect: FirebaseDataConnect by lazy { personSchema.dataConnect }
+
+  @Test
+  fun executeQueryFailsWithNullDataNonEmptyErrors() = runTest {
+    val queryRef =
+      dataConnect.query(
+        operationName = GetPersonQuery.operationName,
+        variables = Arb.incompatibleVariables().next(rs),
+        dataDeserializer = serializer<GetPersonQuery.Data>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { queryRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedMessageSubstringCaseSensitive = "jwdbzka4k5",
+      expectedCause = null,
+      expectedRawData = null,
+      expectedData = null,
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Test
+  fun executeMutationFailsWithNullDataNonEmptyErrors() = runTest {
+    val mutationRef =
+      dataConnect.mutation(
+        operationName = CreatePersonMutation.operationName,
+        variables = Arb.incompatibleVariables().next(rs),
+        dataDeserializer = serializer<CreatePersonMutation.Data>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { mutationRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedCause = null,
+      expectedRawData = null,
+      expectedData = null,
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Test
+  fun executeQueryFailsWithNonNullDataEmptyErrorsButDecodingResponseDataFails() = runTest {
+    val id = Arb.alphanumericString().next()
+    val queryRef =
+      dataConnect.query(
+        operationName = GetPersonQuery.operationName,
+        variables = GetPersonQuery.Variables(id),
+        dataDeserializer = serializer<IncompatibleData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { queryRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "decoding data from the server's response failed",
+      expectedCause = SerializationException::class,
+      expectedRawData = mapOf("person" to null),
+      expectedData = null,
+      expectedErrors = emptyList(),
+    )
+  }
+
+  @Test
+  fun executeMutationFailsWithNonNullDataEmptyErrorsButDecodingResponseDataFails() = runTest {
+    val id = Arb.alphanumericString().next()
+    val name = Arb.alphanumericString().next()
+    val mutationRef =
+      dataConnect.mutation(
+        operationName = CreatePersonMutation.operationName,
+        variables = CreatePersonMutation.Variables(id, name),
+        dataDeserializer = serializer<IncompatibleData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { mutationRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "decoding data from the server's response failed",
+      expectedCause = SerializationException::class,
+      expectedRawData = mapOf("person_insert" to mapOf("id" to id)),
+      expectedData = null,
+      expectedErrors = emptyList(),
+    )
+  }
+
+  @Test
+  fun executeQueryFailsWithNonNullDataNonEmptyErrorsDecodingSucceeds() = runTest {
+    val id = Arb.alphanumericString().next()
+    val name = Arb.alphanumericString().next()
+    personSchema.createPerson(CreatePersonMutation.Variables(id, name)).execute()
+    val queryRef =
+      dataConnect.query(
+        operationName = "getPersonWithPartialFailure",
+        variables = GetPersonWithPartialFailureVariables(id),
+        dataDeserializer = serializer<GetPersonWithPartialFailureData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { queryRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedMessageSubstringCaseSensitive = "c8azjdwz2x",
+      expectedCause = null,
+      expectedRawData = mapOf("person1" to mapOf("name" to name), "person2" to null),
+      expectedData = GetPersonWithPartialFailureData(name),
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Test
+  fun executeMutationFailsWithNonNullDataNonEmptyErrorsDecodingSucceeds() = runTest {
+    val id = Arb.alphanumericString().next()
+    val name = Arb.alphanumericString().next()
+    val mutationRef =
+      dataConnect.mutation(
+        operationName = "createPersonWithPartialFailure",
+        variables = CreatePersonWithPartialFailureVariables(id = id, name = name),
+        dataDeserializer = serializer<CreatePersonWithPartialFailureData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { mutationRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedMessageSubstringCaseSensitive = "ecxpjy4qfy",
+      expectedCause = null,
+      expectedRawData = mapOf("person1" to mapOf("id" to id), "person2" to null),
+      expectedData = CreatePersonWithPartialFailureData(id),
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Test
+  fun executeQueryFailsWithNonNullDataNonEmptyErrorsDecodingFails() = runTest {
+    val id = Arb.alphanumericString().next()
+    val name = Arb.alphanumericString().next()
+    personSchema.createPerson(CreatePersonMutation.Variables(id, name)).execute()
+    val queryRef =
+      dataConnect.query(
+        operationName = "getPersonWithPartialFailure",
+        variables = GetPersonWithPartialFailureVariables(id),
+        dataDeserializer = serializer<IncompatibleData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { queryRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedMessageSubstringCaseSensitive = "c8azjdwz2x",
+      expectedCause = null,
+      expectedRawData = mapOf("person1" to mapOf("name" to name), "person2" to null),
+      expectedData = null,
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Test
+  fun executeMutationFailsWithNonNullDataNonEmptyErrorsDecodingFails() = runTest {
+    val id = Arb.alphanumericString().next()
+    val name = Arb.alphanumericString().next()
+    val mutationRef =
+      dataConnect.mutation(
+        operationName = "createPersonWithPartialFailure",
+        variables = CreatePersonWithPartialFailureVariables(id = id, name = name),
+        dataDeserializer = serializer<IncompatibleData>(),
+        variablesSerializer = serializer(),
+        optionsBuilder = {},
+      )
+
+    val exception = shouldThrow<DataConnectOperationException> { mutationRef.execute() }
+
+    exception.shouldSatisfy(
+      expectedMessageSubstringCaseInsensitive = "operation encountered errors",
+      expectedMessageSubstringCaseSensitive = "ecxpjy4qfy",
+      expectedCause = null,
+      expectedRawData = mapOf("person1" to mapOf("id" to id), "person2" to null),
+      expectedData = null,
+      errorsValidator = { it.shouldHaveAtLeastSize(1) },
+    )
+  }
+
+  @Serializable private data class IncompatibleVariables(val jwdbzka4k5: String)
+
+  @Serializable private data class IncompatibleData(val btzjhbfz7h: String)
+
+  private fun Arb.Companion.incompatibleVariables(string: Arb<String> = Arb.alphanumericString()) =
+    string.map { IncompatibleVariables(it) }
+
+  @Serializable private data class GetPersonWithPartialFailureVariables(val id: String)
+
+  @Serializable
+  private data class GetPersonWithPartialFailureData(val person1: Person, val person2: Nothing?) {
+    constructor(person1Name: String) : this(Person(person1Name), null)
+
+    @Serializable private data class Person(val name: String)
+  }
+
+  @Serializable
+  private data class CreatePersonWithPartialFailureVariables(val id: String, val name: String)
+
+  @Serializable
+  private data class CreatePersonWithPartialFailureData(
+    val person1: Person,
+    val person2: Nothing?
+  ) {
+    constructor(person1Id: String) : this(Person(person1Id), null)
+
+    @Serializable private data class Person(val id: String)
+  }
+}

firebase-dataconnect/src/androidTest/kotlin/com/google/firebase/dataconnect/testutil/schemas/PersonSchema.kt

@@ -54,6 +54,8 @@ class PersonSchema(val dataConnect: FirebaseDataConnect) {
       )
 
   object CreatePersonMutation {
+    const val operationName = "createPerson"
+
     @Serializable
     data class Data(val person_insert: PersonKey) {
       @Serializable data class PersonKey(val id: String)
@@ -63,7 +65,7 @@ class PersonSchema(val dataConnect: FirebaseDataConnect) {
 
   fun createPerson(variables: CreatePersonMutation.Variables) =
     dataConnect.mutation(
-      operationName = "createPerson",
+      operationName = CreatePersonMutation.operationName,
       variables = variables,
       dataDeserializer = serializer<CreatePersonMutation.Data>(),
       variablesSerializer = serializer<CreatePersonMutation.Variables>(),
@@ -141,6 +143,8 @@ class PersonSchema(val dataConnect: FirebaseDataConnect) {
   fun deletePerson(id: String) = deletePerson(DeletePersonMutation.Variables(id = id))
 
   object GetPersonQuery {
+    const val operationName = "getPerson"
+
     @Serializable
     data class Data(val person: Person?) {
       @Serializable data class Person(val name: String, val age: Int? = null)
@@ -151,7 +155,7 @@ class PersonSchema(val dataConnect: FirebaseDataConnect) {
 
   fun getPerson(variables: GetPersonQuery.Variables) =
     dataConnect.query(
-      operationName = "getPerson",
+      operationName = GetPersonQuery.operationName,
       variables = variables,
       dataDeserializer = serializer<GetPersonQuery.Data>(),
       variablesSerializer = serializer<GetPersonQuery.Variables>(),