Switch over to POST when APQ GET requests would be too large

[awb-i4o]

Use case

We are using auto-persisted queries. As we run against a CDN with edge caching, we have chosen GET as a query method. However, sometimes the payload can be quite large, exceeding the limit of 2048 bytes that our API gateway has. Requests with such large payloads cannot be processed by our backend.

Describe the solution you'd like

Would it be possible to make the AutoPersistedQueryInterceptor configurable so that it switches over to POST when the GET query becomes too large? What “too large” means exactly should be definable in the ApolloClient.Builder(), maybe via a parameter of autoPersistedQueries.

[martinbonnin]

autoPersistedQueries() has 2 parameters:

fun autoPersistedQueries(
        httpMethodForHashedQueries: HttpMethod = HttpMethod.Get,
        httpMethodForDocumentQueries: HttpMethod = HttpMethod.Post,
        enableByDefault: Boolean = true,
    )

Could you use Get for hashed queries always and Post for document queries always? I'd be surprised to see an hashed query ending up being larger than 2048 bytes. But maybe I'm missing something?

[awb-i4o]

Thank you for answering, @martinbonnin

The autoPersistedQueries function you quoted above shows the default values which we don't overwrite in our implementation.
Our problem comes from the variables which at times can contain a lot of information. These variables are part of the URL in the GET request.

[martinbonnin]

Our problem comes from the variables

I see. That makes sense, thanks for explaining that!

I don't think we want to build something like this by default because everyone might have different limits there. But you can implement something like this using an ApolloInterceptor:

ApolloClient.Builder()
          .serverUrl(mockServer.url())
          .addInterceptor(object : ApolloInterceptor {
            override fun <D : Operation.Data> intercept(
                request: ApolloRequest<D>,
                chain: ApolloInterceptorChain,
            ): Flow<ApolloResponse<D>> {
              val variablesSize = request.operation.variablesJson(request.executionContext[CustomScalarAdapters]!!).utf8Size()
              
              return if (variablesSize < 1024) {
                chain.proceed(request)
              } else {
                // The GET url might be too long for the infrastructure. Fall back to using POST
                chain.proceed(request.newBuilder().httpMethod(HttpMethod.Post).build())
              }
            }
          })
          .build()

This is wildly untested, so use with caution but I think it should work for your use case. Let me know how that goes!

[awb-i4o]

This is wildly untested, so use with caution but I think it should work for your use case. Let me know how that goes!

It might indeed be a rare edge case that we face, but the byte limit could also be an optional parameter that defaults to null in autoPersistedQueries.

With your proposed solution I ran into some nested JSON exception within buildJsonString, but by using Gson I could achieve what I wanted:

builder.addInterceptor(object : ApolloInterceptor {
    override fun <D : Operation.Data> intercept(
        request: ApolloRequest<D>,
        chain: ApolloInterceptorChain,
    ): Flow<ApolloResponse<D>> {
        val variables = request.operation.variables(builder.customScalarAdapters).valueMap
        val variablesSize = gson.toJson(variables).toString().utf8Size()
        val operationName = request.operation.name()
        // The GET url might be too long for the infrastructure. Fall back to using POST
        return if (variablesSize < 1024) {
            Timber.v("KEEP: %s", operationName)
            chain.proceed(request)
        } else {
            Timber.v("SWITCH TO POST: %s, variables size: %d", operationName, variablesSize)
            chain.proceed(request.newBuilder().httpMethod(HttpMethod.Post).build())
        }
    }
})

Thank you very much. If you like, you can close this now.

[martinbonnin]

Woops, my bad, indeed, serializeVariables() needs to be called inside writeObject{}:

            val variablesSize = buildJsonString { 
              writeObject {
                request.operation.serializeVariables(this, request.executionContext[CustomScalarAdapters]!!, false)
              }
            }.utf8Size()
            

As it turns out, there is even a simpler solution using Operation.variablesJson(). I have edited the code block above to use it. Good old Gson work fine too, thanks for suggesting that 👍 .

the byte limit could also be an optional parameter that defaults to null in autoPersistedQueries.

I hear you. Let's wait a bit. If there are other reports of this, we'll consider adding the API.

you can close this now.

All closed! Thanks for the discussion!

[github-actions]

Do you have any feedback for the maintainers? Please tell us by taking a one-minute survey. Your responses will help us understand Apollo Kotlin usage and allow us to serve you better.