Does apollo coroutine support performing backgrounds operations on a default IO dispatchers

ant2009 0
Viewed 64

I am using apollo with coroutines support

com.apollographql.apollo:apollo-coroutines-support:2.5.4

Just have a few questions. When using apollo.mutate will this fetch using a coroutine background IO dispatcher out of the box?

I think room and retrofit does this. Just wondering about apollo?

Just wondering if I need to create the coroutineScope on the background IO dispatcher explicitly.

Or would I have to do something like this: val coroutineScope = CoroutineScope(Job() + Dispatchers.IO)

Second question is this good practice to use coroutines with apollo in my code below?

    val coroutineScope = CoroutineScope(Job())
    
    suspend fun socialLoginV3(siteCode: String,
                      socialLoginRequest: SocialLoginRequest
    ): String {
        val resultResponse = coroutineScope.async {
            val result: String
            val socialLoginV3Mutation = SocialLoginV3Mutation(
                token = socialLoginRequest.token.toInput(),
                provider = socialLoginRequest.provider.toInput()
            )
            val mutation = apolloClient.mutate(socialLoginV3Mutation)
            val response = mutation.await()

            result = when (response.hasErrors()) {
                true -> {
                    response.errors?.joinToString { error -> error.message } ?: ""
                }
                false -> {
                    response.data?.socialMediaTokenInput?.token ?: ""
                }
            }
            result
        }

        return resultResponse.await()
    }
apollo-client kotlin-coroutines coroutine kotlin
1 Answers

As shown here, when using the coroutines support implementation, the queries and mutate functions should be asynchronous out of the box. Furthermore, Apollo Kotlin 3.x now exposes suspend functions by default, so using apollo-coroutines-support is not needed anymore. Note that some function names have changed (source):

dependencies {
  implementation("com.apollographql.apollo3:apollo-runtime:3.6.0")
}

// Queries are suspend functions
val queryResponse = apolloClient.query(query).execute()
    
// Mutations are suspend functions
val mutationResponse = apolloClient.mutation(mutation).execute()

Regarding your second question. It seems a bit overkill to use a coroutine scope since you are doing only one mutation and apollo supports this out of the box. I think this tutorial is a good starting point that covers everything you need to know for your use case. Below you'll find some adjustments on your code:

fun socialLoginV3(siteCode: String, socialLoginRequest: SocialLoginRequest): String {
    val socialLoginV3Mutation =
        SocialLoginV3Mutation(
            token = socialLoginRequest.token.toInput(),
            provider = socialLoginRequest.provider.toInput()
        )
    val result = apolloClient.mutation(socialLoginV3Mutation).execute()

    response =
        when (result.hasErrors()) {
            true -> {
                result.errors?.joinToString { error -> error.message } ?: ""
            }
            false -> {
                result.data?.socialMediaTokenInput?.token ?: ""
            }
        }

    return response
}
Cloudkollektiv0
Related