[Automated] Merge releases into main (#1776)

Author: github-actions[bot]

.github/workflows/include-check-cache.yml

@@ -93,7 +93,7 @@ jobs:
     # This also include changes to Realm Core as they are hashed as part of `/packages/external/core`
     - name: Calculate ./packages SHAs 
       id: packages-cache-key
-      run: echo "sha=${{ hashFiles('./packages/**', './buildSrc/**', '!./packages/test-base/**', '!./packages/test-sync/**') }}" >> $GITHUB_OUTPUT
+      run: echo "sha=${{ hashFiles('./packages/**', './buildSrc/**') }}" >> $GITHUB_OUTPUT
 
     - name: Calculate ./benchmarks SHAs 
       id: calculate-benchmarks-cache-key

CHANGELOG.md

@@ -27,6 +27,35 @@
 ### Internal
 - None.
 
+## 2.0.1 (YYYY-MM-DD)
+
+### Breaking changes
+* None.
+
+### Enhancements
+* None.
+
+### Fixed
+* [Sync] Fatal sync exceptions are now thrown as `UnrecoverableSyncException`. (Issue [#1767](https://github.com/realm/realm-kotlin/issues/1767) [RKOTLIN-1096](https://jira.mongodb.org/browse/RKOTLIN-1096)).
+* [Sync] Fix `NullPointerException` in `SubscriptionSet.waitForSynchronization`. (Issue [#1777](https://github.com/realm/realm-kotlin/issues/1777) [RKOTLIN-1102](https://jira.mongodb.org/browse/RKOTLIN-1102)).
+
+### Compatibility
+* File format: Generates Realms with file format v24 (reads and upgrades file format v10 or later).
+* Realm Studio 15.0.0 or above is required to open Realms created by this version.
+* This release is compatible with the following Kotlin releases:
+  * Kotlin 2.0.0 and above. Support for experimental K2-compilation with `kotlin.experimental.tryK2=true`.
+  * Ktor 2.1.2 and above.
+  * Coroutines 1.7.0 and above.
+  * AtomicFu 0.18.3 and above.
+  * The new memory model only. See https://github.com/realm/realm-kotlin#kotlin-memory-model-and-coroutine-compatibility
+* Minimum Kbson 0.4.0.
+* Minimum Gradle version: 7.2.
+* Minimum Android Gradle Plugin version: 7.1.3.
+* Minimum Android SDK: 16.
+* Minimum R8: 8.0.34.
+
+### Internal
+- None.
 
 ## 2.0.0 (2024-06-03)
 

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/exceptions/RealmException.kt

@@ -9,7 +9,7 @@ package io.realm.kotlin.exceptions
  */
 public open class RealmException : RuntimeException {
     public constructor() : super()
-    public constructor(message: String) : super(message)
-    public constructor(message: String, cause: Throwable) : super(message, cause)
-    public constructor(cause: Throwable) : super(cause)
+    public constructor(message: String?) : super(message)
+    public constructor(message: String?, cause: Throwable?) : super(message, cause)
+    public constructor(cause: Throwable?) : super(cause)
 }

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/exceptions/AppException.kt

@@ -94,5 +94,5 @@ import io.realm.kotlin.exceptions.RealmException
  * @see SyncException
  */
 public open class AppException internal constructor(
-    message: String,
+    message: String?,
 ) : RealmException(message)

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/exceptions/SyncExceptions.kt

@@ -31,7 +31,7 @@ import io.realm.kotlin.types.RealmAny
  *
  * @see io.realm.kotlin.mongodb.sync.SyncConfiguration.Builder.errorHandler
  */
-public open class SyncException internal constructor(message: String) : AppException(message)
+public open class SyncException internal constructor(message: String?) : AppException(message)
 
 /**
  * Thrown when something has gone wrong with Device Sync in a way that is not recoverable.
@@ -60,7 +60,7 @@ public class WrongSyncTypeException internal constructor(message: String) : Sync
  * Thrown when the server does not support one or more of the queries defined in the
  * [io.realm.kotlin.mongodb.sync.SubscriptionSet].
  */
-public class BadFlexibleSyncQueryException internal constructor(message: String) :
+public class BadFlexibleSyncQueryException internal constructor(message: String?) :
     SyncException(message)
 
 /**

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/internal/RealmSyncUtils.kt

@@ -78,26 +78,34 @@ internal fun <T, R> channelResultCallback(
 internal fun convertSyncError(syncError: SyncError): SyncException {
     val errorCode = syncError.errorCode
     val message = createMessageFromSyncError(errorCode)
-    return when (errorCode.errorCode) {
-        ErrorCode.RLM_ERR_WRONG_SYNC_TYPE -> WrongSyncTypeException(message)
+    return if (syncError.isFatal) {
+        // An unrecoverable exception happened
+        UnrecoverableSyncException(message)
+    } else {
+        when (errorCode.errorCode) {
+            ErrorCode.RLM_ERR_WRONG_SYNC_TYPE -> WrongSyncTypeException(message)
 
-        ErrorCode.RLM_ERR_INVALID_SUBSCRIPTION_QUERY -> {
-            // Flexible Sync Query was rejected by the server
-            BadFlexibleSyncQueryException(message)
-        }
-        ErrorCode.RLM_ERR_SYNC_COMPENSATING_WRITE -> CompensatingWriteException(message, syncError.compensatingWrites)
+            ErrorCode.RLM_ERR_INVALID_SUBSCRIPTION_QUERY -> {
+                // Flexible Sync Query was rejected by the server
+                BadFlexibleSyncQueryException(message)
+            }
 
-        ErrorCode.RLM_ERR_SYNC_PROTOCOL_INVARIANT_FAILED,
-        ErrorCode.RLM_ERR_SYNC_PROTOCOL_NEGOTIATION_FAILED,
-        ErrorCode.RLM_ERR_SYNC_PERMISSION_DENIED -> {
-            // Permission denied errors should be unrecoverable according to Core, i.e. the
-            // client will disconnect sync and transition to the "inactive" state
-            UnrecoverableSyncException(message)
-        }
-        else -> {
-            // An error happened we are not sure how to handle. Just report as a generic
-            // SyncException.
-            SyncException(message)
+            ErrorCode.RLM_ERR_SYNC_COMPENSATING_WRITE -> CompensatingWriteException(
+                message,
+                syncError.compensatingWrites
+            )
+            ErrorCode.RLM_ERR_SYNC_PROTOCOL_INVARIANT_FAILED,
+            ErrorCode.RLM_ERR_SYNC_PROTOCOL_NEGOTIATION_FAILED,
+            ErrorCode.RLM_ERR_SYNC_PERMISSION_DENIED -> {
+                // Permission denied errors should be unrecoverable according to Core, i.e. the
+                // client will disconnect sync and transition to the "inactive" state
+                UnrecoverableSyncException(message)
+            }
+            else -> {
+                // An error happened we are not sure how to handle. Just report as a generic
+                // SyncException.
+                SyncException(message)
+            }
         }
     }
 }

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/internal/SubscriptionSetImpl.kt

@@ -127,7 +127,7 @@ internal class SubscriptionSetImpl<T : BaseRealm>(
                     if (result) {
                         return true
                     } else {
-                        throw BadFlexibleSyncQueryException(errorMessage!!)
+                        throw BadFlexibleSyncQueryException(errorMessage)
                     }
                 }
                 else -> throw IllegalStateException("Unexpected value: $result")

packages/test-sync/src/commonTest/kotlin/io/realm/kotlin/test/mongodb/common/CredentialsTests.kt

@@ -369,7 +369,7 @@ class CredentialsTests {
             payload = mapOf("mail" to TestHelper.randomEmail(), "id" to 0)
         )
 
-        assertFailsWithMessage<AuthException>("unauthorized") {
+        assertFailsWithMessage<AuthException>("Authentication failed") {
             runBlocking {
                 app.login(credentials)
             }

packages/test-sync/src/commonTest/kotlin/io/realm/kotlin/test/mongodb/common/SyncedRealmTests.kt

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-@file:Suppress("invisible_reference", "invisible_member")
+@file:Suppress("invisible_member", "invisible_reference")
 
 package io.realm.kotlin.test.mongodb.common
 
@@ -28,15 +28,19 @@ import io.realm.kotlin.entities.sync.flx.FlexChildObject
 import io.realm.kotlin.entities.sync.flx.FlexEmbeddedObject
 import io.realm.kotlin.entities.sync.flx.FlexParentObject
 import io.realm.kotlin.ext.query
+import io.realm.kotlin.internal.interop.ErrorCode
+import io.realm.kotlin.internal.interop.RealmInterop
 import io.realm.kotlin.internal.platform.fileExists
 import io.realm.kotlin.internal.platform.pathOf
 import io.realm.kotlin.internal.platform.runBlocking
 import io.realm.kotlin.log.RealmLog
 import io.realm.kotlin.mongodb.App
+import io.realm.kotlin.mongodb.Credentials
 import io.realm.kotlin.mongodb.User
 import io.realm.kotlin.mongodb.exceptions.DownloadingRealmTimeOutException
 import io.realm.kotlin.mongodb.exceptions.SyncException
 import io.realm.kotlin.mongodb.exceptions.UnrecoverableSyncException
+import io.realm.kotlin.mongodb.internal.SyncSessionImpl
 import io.realm.kotlin.mongodb.subscriptions
 import io.realm.kotlin.mongodb.sync.InitialSubscriptionsCallback
 import io.realm.kotlin.mongodb.sync.SubscriptionSetState
@@ -313,6 +317,56 @@ class SyncedRealmTests {
         realm3.close()
     }
 
+    @Test
+    fun errorHandlerProcessFatalSyncErrors() {
+        val channel = TestChannel<Throwable>()
+        val user = runBlocking {
+            app.login(Credentials.anonymous())
+        }
+
+        val config = SyncConfiguration.Builder(
+            schema = setOf(ParentPk::class, ChildPk::class),
+            user = user,
+            partitionValue = partitionValue
+        ).errorHandler { _, error ->
+            channel.trySendOrFail(error)
+        }.build()
+
+        runBlocking {
+            val deferred = async {
+                Realm.open(config).use { realm ->
+                    RealmInterop.realm_sync_session_handle_error_for_testing(
+                        syncSession = (realm.syncSession as SyncSessionImpl).nativePointer,
+                        error = ErrorCode.RLM_ERR_ACCOUNT_NAME_IN_USE,
+                        errorMessage = "Non fatal error",
+                        isFatal = true, // flipped https://jira.mongodb.org/browse/RCORE-2146
+                    )
+
+                    RealmInterop.realm_sync_session_handle_error_for_testing(
+                        syncSession = (realm.syncSession as SyncSessionImpl).nativePointer,
+                        error = ErrorCode.RLM_ERR_INTERNAL_SERVER_ERROR,
+                        errorMessage = "Fatal error",
+                        isFatal = false, // flipped https://jira.mongodb.org/browse/RCORE-2146
+                    )
+                }
+            }
+
+            // First error
+            channel.receiveOrFail().let { error ->
+                assertNotNull(error.message)
+                assertIs<SyncException>(error)
+            }
+
+            // Second
+            channel.receiveOrFail().let { error ->
+                assertNotNull(error.message)
+                assertIs<UnrecoverableSyncException>(error)
+            }
+
+            deferred.cancel()
+        }
+    }
+
     @Test
     fun errorHandlerReceivesPermissionDeniedSyncError() {
         val channel = TestChannel<Throwable>()
@@ -336,15 +390,15 @@ class SyncedRealmTests {
                 Realm.open(config).use {
                     // Make sure that the test eventually fail. Coroutines can cancel a delay
                     // so this doesn't always block the test for 10 seconds.
-                    delay(10 * 1000)
+                    delay(10_000)
                     channel.send(AssertionError("Realm was successfully opened"))
                 }
             }
 
             val error = channel.receiveOrFail()
-            assertTrue(error is UnrecoverableSyncException, "Was $error")
             val message = error.message
             assertNotNull(message)
+            assertTrue(error is UnrecoverableSyncException, "Was $error")
             assertTrue(
                 message.lowercase().contains("permission denied"),
                 "The error should be 'PermissionDenied' but it was: $message"