Refactor(service): Separate network calls from Realm transactions #8910

dogi · 2025-11-05T19:21:57Z

Refactored the UploadToShelfService to use a coroutine-based approach for handling data uploads. This change separates network operations from Realm database transactions to prevent long-running transactions and improve performance.

Replaced executeTransactionAsync with kotlinx.coroutines.launch and withContext(Dispatchers.IO).
Decoupled database reads, network calls, and database writes into distinct steps.
Removed the class-level mRealm instance in favor of short-lived, transaction-specific instances.
Updated uploadUserData, uploadSingleUserData, uploadToShelf, uploadSingleUserToShelf, uploadHealth, and uploadSingleUserHealth to follow the new architecture.

https://jules.google.com/session/9907850505057940493

Refactored the `UploadToShelfService` to use a coroutine-based approach for handling data uploads. This change separates network operations from Realm database transactions to prevent long-running transactions and improve performance. - Replaced `executeTransactionAsync` with `kotlinx.coroutines.launch` and `withContext(Dispatchers.IO)`. - Decoupled database reads, network calls, and database writes into distinct steps. - Removed the class-level `mRealm` instance in favor of short-lived, transaction-specific instances. - Updated `uploadUserData`, `uploadSingleUserData`, `uploadToShelf`, `uploadSingleUserToShelf`, `uploadHealth`, and `uploadSingleUserHealth` to follow the new architecture.

qltysh · 2025-11-05T19:23:04Z

❌ 6 blocking issues (6 total)

Tool	Category	Rule	Count
qlty	Structure	Function with high complexity (count = 58): uploadUserData	2	❌
qlty	Structure	Deeply nested control flow (level = 5)	2	❌
qlty	Duplication	Found 26 lines of identical code in 2 locations (mass = 214)	2	❌

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

chatgpt-codex-connector

💡 Codex Review

myplanet/app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

Lines 279 to 285 in 8646b05

    
           val jsonElement = gson.toJsonTree(mutableObj) 
        
           val jsonObject = jsonElement.asJsonObject 
        
           val updateResponse = apiInterface.putDoc(header, "application/json", "${replacedUrl(model)}/_users/org.couchdb.user:${model.name}", jsonObject).execute() 
        
           if (updateResponse.isSuccessful) { 
        
               val updatedRev = updateResponse.body()?.get("rev")?.asString

Close Realm instance when updating health records

updateHealthData now calls dbService.realmInstance.executeTransaction { … } but never closes the Realm instance returned by realmInstance. Each call leaks a Realm.getDefaultInstance() and Android will eventually throw IllegalStateException: Realm instance has been leaked once the open instance limit is reached. Use dbService.realmInstance.use { it.executeTransaction { … } } or the provided withRealm helper so the instance is closed after the transaction.

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2025-11-05T19:24:51Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

                model.iterations = getString("iterations", fetchDataResponse.body())

                if (saveKeyIv(apiInterface, model, obj)) {
-                    updateHealthData(realm, model)
+                    updateHealthData(model.id, model._id)
                }
            }
        } catch (e: IOException) {


Persist updated user flags back to Realm

The refactor now works on unmanaged copies of RealmUserModel, but updateExistingUser only mutates the copy (model._rev/model.isUpdated) without writing those changes back to Realm. Because the caller obtained its models via realm.copyFromRealm, the database never clears the isUpdated flag nor stores the new revision, so the same users will be re-sent on every sync and the local _rev stays stale. Wrap these assignments in a Realm transaction so the managed record is updated.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2025-11-05T19:24:51Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

                val rev = createResponse.body()?.get("rev")?.asString
                model._id = id
                model._rev = rev
-                processUserAfterCreation(apiInterface, realm, model, obj)
+                processUserAfterCreation(apiInterface, model, obj)
            }
        } catch (e: IOException) {
            e.printStackTrace()


Save new user metadata after single-user sync

When uploadSingleUserData creates a user, uploadNewUser and processUserAfterCreation populate _id, _rev, password keys and health references on the detached RealmUserModel copy but never persist those changes. The previous version modified a managed model inside a Realm transaction, so the database was updated. After this commit, the local realm still lacks the assigned CouchDB id and security fields, which breaks follow-up shelf/health uploads for that user. The helper should write the new values to Realm before returning.

Useful? React with 👍 / 👎.

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2025-11-05T19:24:59Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                                            dbService.realmInstance.use { realm ->
+                                                realm.executeTransaction {
+                                                    val managedModel = it.where(RealmUserModel::class.java).equalTo("id", model.id).findFirst()
+                                                    managedModel?._id = id
+                                                    managedModel?._rev = rev
+                                                    managedModel?.password_scheme = passwordScheme
+                                                    managedModel?.derived_key = derivedKey
+                                                    managedModel?.salt = salt
+                                                    managedModel?.iterations = iterations
+                                                    if (keyIvResult) {
+                                                        managedModel?.key = model.key
+                                                        managedModel?.iv = model.iv
+                                                    }
+                                                    updateHealthData(managedModel?.id, managedModel?._id)
+                                                }


Avoid starting a second Realm transaction inside an active one

Within uploadUserData the code updates the newly created user using realm.executeTransaction { … updateHealthData(managedModel?.id, managedModel?._id) } while updateHealthData itself now calls dbService.realmInstance.executeTransaction { … }. This nests a new write transaction (and opens a new Realm instance) while the original transaction is still running on the same thread. Realm forbids nested write transactions and will throw IllegalStateException: Cannot execute transaction while in a transaction, causing the sync to fail for every new user. The previous implementation reused the existing realm instance and avoided this error.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2025-11-05T19:24:59Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

        val apiInterface = client?.create(ApiInterface::class.java)
-        mRealm = dbService.realmInstance
-
-        mRealm.executeTransactionAsync({ realm: Realm ->
-            val userModel = realm.where(RealmUserModel::class.java)
-                .equalTo("name", userName)
-                .findFirst()
-
-            if (userModel != null) {
-                try {
-                    val password = SecurePrefs.getPassword(context, sharedPreferences) ?: ""
-                    val header = "Basic ${Base64.encodeToString(("${userModel.name}:${password}").toByteArray(), Base64.NO_WRAP)}"
+        MainApplication.applicationScope.launch {
+            try {
+                val userModel = withContext(Dispatchers.IO) {
+                    dbService.realmInstance.use { realm ->
+                        val user = realm.where(RealmUserModel::class.java)
+                            .equalTo("name", userName)
+                            .findFirst()
+                        user?.let { realm.copyFromRealm(it) }
+                    }
+                }

-                    val userExists = checkIfUserExists(apiInterface, header, userModel)
+                if (userModel != null) {
+                    withContext(Dispatchers.IO) {
+                        val password = SecurePrefs.getPassword(context, sharedPreferences) ?: ""
+                        val header = "Basic ${Base64.encodeToString(("${userModel.name}:${password}").toByteArray(), Base64.NO_WRAP)}"
+                        val userExists = checkIfUserExists(apiInterface, header, userModel)

-                    if (!userExists) {
-                        uploadNewUser(apiInterface, realm, userModel)
-                    } else if (userModel.isUpdated) {
-                        updateExistingUser(apiInterface, header, userModel)
+                        if (!userExists) {
+                            uploadNewUser(apiInterface, userModel)
+                        } else if (userModel.isUpdated) {
+                            updateExistingUser(apiInterface, header, userModel)
+                        }
                    }
-                } catch (e: IOException) {
-                    e.printStackTrace()
+                }


Persist single-user sync updates back to Realm

uploadSingleUserData copies the user from Realm (realm.copyFromRealm) and then calls uploadNewUser/updateExistingUser on that detached copy. Those helpers no longer write the updated _id, _rev, or isUpdated flags back into the database, so the local Realm is never updated after the network request. As a result, the same user will continue to appear as unsynced and shelf uploads will still see a null _id. The previous code operated on managed objects inside a transaction, so state was persisted. This path needs to write the modified user back to Realm after the network call.

Useful? React with 👍 / 👎.

Refactored the `UploadToShelfService` to use a coroutine-based approach for handling data uploads. This change separates network operations from Realm database transactions to prevent long-running transactions and improve performance. - Replaced `executeTransactionAsync` with `kotlinx.coroutines.launch` and `withContext(Dispatchers.IO)`. - Decoupled database reads, network calls, and database writes into distinct steps. - Removed the class-level `mRealm` instance in favor of short-lived, transaction-specific instances. - Updated `uploadUserData`, `uploadSingleUserData`, `uploadToShelf`, `uploadSingleUserToShelf`, `uploadHealth`, and `uploadSingleUserHealth` to follow the new architecture. - Fixed a regression where `uploadSingleUserData` was not persisting changes to the database.

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                    listener.onSuccess("Error during user data sync: ${e.localizedMessage}")
+                }
+            }
        }


Function with high complexity (count = 58): uploadUserData [qlty:function-complexity]

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                                                    managedModel?.iterations = iterations
+                                                    if (keyIvResult) {
+                                                        managedModel?.key = model.key
+                                                        managedModel?.iv = model.iv


Deeply nested control flow (level = 5) [qlty:nested-control-flow]

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                                                    managedModel?._rev = updatedRev
+                                                    managedModel?.isUpdated = false
+                                                }
+                                            }


Deeply nested control flow (level = 5) [qlty:nested-control-flow]

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                                e.printStackTrace()
+                            }
+                        }
                    }


Found 26 lines of identical code in 2 locations (mass = 214) [qlty:identical-code]

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

-        }) { error ->
-            mRealm.close()
-            listener?.onSuccess("Error uploading health data for user $userId: ${error.localizedMessage}")
        }


Function with high complexity (count = 18): uploadSingleUserHealth [qlty:function-complexity]

qltysh · 2025-11-05T19:45:50Z

app/src/main/java/org/ole/planet/myplanet/service/UploadToShelfService.kt

+                                e.printStackTrace()
+                            }
+                        }
                    }


Found 26 lines of identical code in 2 locations (mass = 214) [qlty:identical-code]

qltysh bot reviewed Nov 5, 2025

View reviewed changes

chatgpt-codex-connector bot reviewed Nov 5, 2025

View reviewed changes

qltysh bot reviewed Nov 5, 2025

View reviewed changes

dogi added triage Further information is requested brainstorm experiment close? labels Nov 5, 2025

dogi closed this Nov 10, 2025

dogi reopened this Nov 10, 2025

dogi removed the close? label Nov 10, 2025

	val jsonElement = gson.toJsonTree(mutableObj)
	val jsonObject = jsonElement.asJsonObject

	val updateResponse = apiInterface.putDoc(header, "application/json", "${replacedUrl(model)}/_users/org.couchdb.user:${model.name}", jsonObject).execute()

	if (updateResponse.isSuccessful) {
	val updatedRev = updateResponse.body()?.get("rev")?.asString

Refactor(service): Separate network calls from Realm transactions #8910

Are you sure you want to change the base?

Refactor(service): Separate network calls from Realm transactions #8910

Uh oh!

Conversation

dogi commented Nov 5, 2025

Uh oh!

qltysh bot commented Nov 5, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

❌ 6 blocking issues (6 total)

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

qltysh bot Nov 5, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

qltysh bot commented Nov 5, 2025 •

edited

Loading