Hello everyone! We are going to start internationalising our app and we've selected the variant per country approach. Each variant will point to a backend instance which will have its own schema ( which will have similar types and custom per country types), If I understood correctly I could use

createAllAndroidVariantServices

so each variants will have their corresponding generated code, which is good. It seems though than when mapping to a domain layer I'd have to replicate mappers for the shared components ( one mapper that target each variant source code) which its a bit tedious. Has someone faced a similar scenario and could share maybe a better solution/ approach ?

Hi, we have a custom Gradle convention plugin to pre-setup ApolloExtension. However, with compulsory service name definition, "later" we are unable to modify the plugins configuration in the actual gradle.kts file - as the service has to be defined at once. What is the solution here?

Got a question regarding apollo-kotlin and using an

okhttp3.Authenticator

with it. So my use case is as such. We use okhttp interceptors to append the Auth token on our requests, and an

okhttp3.Authenticator

to respond to 401s by refreshing token, retrying the request and so on. Thing is, apparently sometimes we get the 401 inside the graphql response with a 200 header so we can’t entirely rely on the

okhttp3.Authenticator

to check these not authorized cases, but we need an okhttp interceptor on top of it to catch those cases too. Is my best bet to simply use a

com.apollographql.apollo3.interceptor.ApolloInterceptor

, look at the response body for the 401 in the error codes, and do what my

okhttp3.Authenticator

would do? Is it weird that our backend responds with 200 but 401 in the error message itself? I also worry about concurrent access from both my

okhttp3.Authenticator

and my

com.apollographql.apollo3.interceptor.ApolloInterceptor

both trying to get the refresh token and create a new access token. I guess I’d also need to manage the concurrency by locking on whatever class they both access, instead of locking inside the two authenticators/interceptors themselves. Just asking here to see if I am going in the right direction or if I am missing something super obvious that would make my life easier 🤩

👋 Sorry this might be a silly one, but Im trying to move to variant services for apollo kotlin. Im following the doc But Im getting a

Could not set unknown property 'nameSuffix' for extension 'apollo'

🤔

Hey all, I have a question about caching lists. If there is a filterable list, that returns a list of nodes, and we were to call a mutation that would add or remove a node from the list (or even pagination), how do we update the cache of the list? Or am I just thinking about this wrong? Example: • Let's say there is a searchable list of users, and with out search text the query returns the whole list. • But then we start to type in the search field and make a new query. • Then we call a mutation that deleted Bob Smith (or even added a new Bob Smith) I think the cache would look something like this:

Account:12345.users()
Account:12345.users({search: "Bob"})
Account:12345.users({search: "Bob Smith"})

The problem is that we want to update the cache for all the lists after the mutation succeeded. I have thought about updating the cache manually with

writeOperation

but we would run into not knowing every single search query text, or having to keep a list of every time a query was made with the search text. The same would apply trying to use refetch queries in the mutation collect, or even just deleting the cache key from the store with

apollo.apolloStore.remove(CacheKey(key))

.

Hello, World! :android-wave: We're are currently thinking of removing the idling resource in the next major version of the library as it seems to have become less of a good practice nowadays - see this comment from OkHttp for instance, and this article about how to avoid them with Compose. Any objections against this?

My GraphQL server has a scalar type which converts to a list (ugh!). If I try to create a custom type mapping to

"kotlin.List<kotlin.String>"

I get an invalid character on

<

. Is there a way to have my custom type mapping be a list? If not, I'll create a wrapper type.

My backend is sending Unauthorised wrapped in a 200 response and the actual error in the body. So in my AuthInterceptor I have to read the body to determine if I should refresh my token and re-do the original request. What is the correct way to read the body?

HttpResponse.body

returns BufferedSource and I am not sure how to read it without closing the stream. The json parsing itself is pretty simple so I am fine with manually parsing but I get an exception with my current code

hey quick question in regards to the incubating cache artifacts for pagination support. Do you expect those to be mainlined at some point in the near future? Or should we continue proceeding at risk of changes?

I am using OkhttpClient with ApolloClient ( version 3.7.4). When user switches profile, I close the ApolloClient

close()

and create new ApolloClient with the same OkHttpClient instance. But this is not working. None of the

query

or

mutation

operation result in any http request. ( Confirmed using charles) Everything works as expected if I don't call

.close()

. I need to call

.close()

to terminate subscriptions for the

older

profile and then create new subscriptions. Does anyone know what's happening under the hood when ApolloClient.

close()

is called?

Hi everyone, I am running into a weird issue in regards to parsing (kinda continued from a couple message above).. My GraphQL schema defines the queries like

type Query {
  games: [Games!]!
}

This results in a Response adapter with the following fromJson code

public override fun fromJson(reader: JsonReader, customScalarAdapters: CustomScalarAdapters): GetGamesQuery.Data {
      var _games: List<GetGamesQuery.AllAccount>? = null

      while(true) {
        when (reader.selectName(RESPONSE_NAMES)) {
          0 -> _games = Games.obj().list().fromJson(reader, customScalarAdapters)
          else -> break
        }
      }

      return GetGamesQuery.Data(
        games = _games!!
      )
    }

But when my server encounters a “GraphQL” when running this query, the response that it sends down fails to parse, details in 🧵

Hey all, I am writing an integration test for a service that contacts another service using graphql with apollo client. What is the best approach for mocking the service? Is a regular http mock server a reasonable approach? I’ll mention that the test is dockerized. Thanks!

I have a thought that I’d like to hear opinions about. I know toFlow() exists, where you can simply call that instead of

execute

on an operation, since that’s what it does internally anyway. So at any query we could theoretically replace it with

toFlow

and assume all responses can return more results instead of just one (I think with deferred responses that’s was the idea) Now I have a screen in Android, where I was checking out removing all configuration changes, so I applied all of these and let compose handle all config changes (testing language changes here in my case). Thing is, for that screen I am testing, I realize we have one part of the screen which shows some string that comes from the backend as-is, meaning it takes what locale header we send it, and responds accordingly, while the other strings of the text are local, so they update immediately when we do a language change, which does not restart the activity, since the Apollo query isn’t re-fetched obviously. If I let the activity re-create itself I get that for free since the entire thing restarts from the beginning. So finally what I am wondering about. Is there any way I can somehow hook something into the apollo-client, so that if there is ever a locale change, I can ask it to re-fetch every flow it’s got open at the moment, where it will then fetch the correct locale since the interceptor will then get the correctly changed locale and append it in the HTTP headers? Does this idea even make sense conceptually? 😄

Sorry if this has been asked already but is there way to rename/alias a property in query/result?

first time working with apollo kotlin. trying to add apollo-kotlin to a new module i created. when i sync i get this error. Am I missing something fundamental here? Edit: fairly certain something is either wrong with apollo-kotlin or maven central?

Continuing with yesterday. I'm trying to get a demo of graphql working. I'm following the "get started instructions" but I'm kinda confused at this part Don't I need to call that command with some sort of URL pointing to the schema?

It's possible to use apollo3 and an older version of apollo in the same app, right?

I'm trying to get Apollo working on a JS target. The same code on Android/JVM works fine, on JS it throws an exception "SubscriptionOperationException: Operation error <subscriptionName>". Is there anything JS-specific with subscriptions that I should know?

In apollo3 should me schema and query look like this in the file tree? Or should I be moving it under a package? like src/main/graphql/com.example.myapp?

Is a query stateful in any way? My example. I have a class called GetBooksService which takes in a Singleton ApolloClient (provided by dagger). GetBooksService is also going to be provided by dagger for callers to use, and GetBooksService is pretty simple:

//pseudocode
returnresponse = apolloClient.query(GetBooksQUery(10)).execute()

so GetBooksService is pretttttty thin, but is there anything stateful about it? This is important for me to know because I currently have the service marked as a

@Singleton

but i know marking something as a singleton thats not stateful is wasteful

hey quick question. do apolloUsedCoordinates support multiple services?

> No matching variant of project :domain was found. The consumer was configured to find a usage of 'apollo-used-coordinates' of a component, as well as attribute 'com.apollographql.service' with value 'api' but

but we only use the service from

api2

in that module.

Random question, Is there a way to stop

CacheAndNetwork

from emitting 2 values when the cache value and network value are the same?

Any reason why Apollo client ( v3.7.4) throws ApolloNetworkException when response code is 401

I start a subscription as seen in the code snippet. My understanding is that it will catch any exceptions and restart the flow but in reality , my app is crashing with the exception below.

subscription(someSubscription).toFlow().retryWhen { t, attempt ->
    delay(attempt * attempt * 10000)
    true
}

java.io.EOFException: null
    at okio.RealBufferedSource.require(RealBufferedSource.kt:199)
    at okio.RealBufferedSource.readByte(RealBufferedSource.kt:209)
    at okhttp3.internal.ws.WebSocketReader.readHeader(WebSocketReader.kt:119)
    at okhttp3.internal.ws.WebSocketReader.processNextFrame(WebSocketReader.kt:102)
    at okhttp3.internal.ws.RealWebSocket.loopReader(RealWebSocket.kt:293)
    at okhttp3.internal.ws.RealWebSocket$connect$1.onResponse(RealWebSocket.kt:195)
    at okhttp3.internal.connection.RealCall$AsyncCall.run(RealCall.kt:519)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
    at java.lang.Thread.run(Thread.java:764)
com.apollographql.apollo3.exception.ApolloNetworkException: Network error while executing onDisplayTimeUpdated
    at com.apollographql.apollo3.network.ws.WebSocketNetworkTransport$execute$$inlined$map$1$2.emit(Emitters.kt:246)
    at kotlinx.coroutines.flow.internal.SafeCollectorKt$emitFun$1.invoke(SafeCollector.kt:15)
    at kotlinx.coroutines.flow.internal.SafeCollectorKt$emitFun$1.invoke(SafeCollector.kt:15)
    at kotlinx.coroutines.flow.internal.SafeCollector.emit(SafeCollector.kt:87)
    at kotlinx.coroutines.flow.internal.SafeCollector.emit(SafeCollector.kt:66)
    at com.apollographql.apollo3.network.ws.WebSocketNetworkTransport$execute$3.invokeSuspend(WebSocketNetworkTransport.kt:271)
    at com.apollographql.apollo3.network.ws.WebSocketNetworkTransport$execute$3.invoke
    at com.apollographql.apollo3.network.ws.WebSocketNetworkTransport$execute$3.invoke
    at com.apollographql.apollo3.internal.FlowsKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$1.emit(flows.kt:53)
    at com.apollographql.apollo3.internal.FlowsKt$transformWhile$1$invokeSuspend$$inlined$collectWhile$2.emit(flows.kt:38)
    at com.apollographql.apollo3.network.ws.WebSocketNetworkTransport$execute$$inlined$filter$1$2.emit(Emitters.kt:223)
    at kotlinx.coroutines.flow.SubscribedFlowCollector.emit
    at kotlinx.coroutines.flow.SharedFlowImpl.collect$suspendImpl(SharedFlow.kt:383)
    at kotlinx.coroutines.flow.SharedFlowImpl$collect$1.invokeSuspend
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
    at kotlinx.coroutines.internal.LimitedDispatcher.run(LimitedDispatcher.kt:42)
    at kotlinx.coroutines.scheduling.TaskImpl.run(Tasks.kt:95)
    at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)

How do folks "mock" their apollo service? For example, I know retrofit has a mocking artifact. I guess since apollo uses okhttp I can just use a mock okhttp server too here and that should work? (or maybe actually i can use mock okhttp server no matter what client is actually in use 🤔 ) but yeah. how are you mocking this sort of stuff out? ideally i guess itd be nice to have some json files that match up to deterministic resopnses and just read from those files when a proper query is hit.

To that note ^ - we have new schema that won’t be in the graph for awhile and we want to mock out that query only. We were thinking of using the network transport apis to intercept the request and delegate it to the test network transport when it finds a match. The schema we will include as a separate file alongside the regular schema and extend the Query type to add its query . Is this a good approach?

a question around data builders. We started using them and am running into errors like

Don't know how to instantiate leaf URL

We have a set of scalar adapters which are correctly fed into the databuilders. in the

fakeResolver

the order of operations is such:

val leafValue = resolver.resolveLeaf(FakeResolverContext(path, id, mergedField))
          if (type is CustomScalarType) {

the

resolver

itself seems to run without any knowledge of scalars in the `DefaultFakeResolver`:

else -> {
        val type = enumTypes.find { it.name == name } ?: error("Don't know how to instantiate leaf $name")

is this expected? I could not find anything in the docs for data builders

hey - I'm pretty new to using the Apollo Gradle Plugin and GraphQL. I noticed that the

generateApolloSources

task will generate some data classes that are exactly the same, is there a way to configure the plugin so that only one of each of these classes is generated and they are re-used in the respective queries?

Is there a way when using the

CacheAndNetwork

fetch policy to know if the data coming through the flow is from cache or if it's from the network?